# Generated from .\OpenSCENARIO2.g4 by ANTLR 4.10.1
# encoding: utf-8
import sys
from io import StringIO

from antlr4 import *

if sys.version_info[1] > 5:
    from typing import TextIO
else:
    from typing.io import TextIO


def serializedATN():
    return [
        4,
        1,
        95,
        1318,
        2,
        0,
        7,
        0,
        2,
        1,
        7,
        1,
        2,
        2,
        7,
        2,
        2,
        3,
        7,
        3,
        2,
        4,
        7,
        4,
        2,
        5,
        7,
        5,
        2,
        6,
        7,
        6,
        2,
        7,
        7,
        7,
        2,
        8,
        7,
        8,
        2,
        9,
        7,
        9,
        2,
        10,
        7,
        10,
        2,
        11,
        7,
        11,
        2,
        12,
        7,
        12,
        2,
        13,
        7,
        13,
        2,
        14,
        7,
        14,
        2,
        15,
        7,
        15,
        2,
        16,
        7,
        16,
        2,
        17,
        7,
        17,
        2,
        18,
        7,
        18,
        2,
        19,
        7,
        19,
        2,
        20,
        7,
        20,
        2,
        21,
        7,
        21,
        2,
        22,
        7,
        22,
        2,
        23,
        7,
        23,
        2,
        24,
        7,
        24,
        2,
        25,
        7,
        25,
        2,
        26,
        7,
        26,
        2,
        27,
        7,
        27,
        2,
        28,
        7,
        28,
        2,
        29,
        7,
        29,
        2,
        30,
        7,
        30,
        2,
        31,
        7,
        31,
        2,
        32,
        7,
        32,
        2,
        33,
        7,
        33,
        2,
        34,
        7,
        34,
        2,
        35,
        7,
        35,
        2,
        36,
        7,
        36,
        2,
        37,
        7,
        37,
        2,
        38,
        7,
        38,
        2,
        39,
        7,
        39,
        2,
        40,
        7,
        40,
        2,
        41,
        7,
        41,
        2,
        42,
        7,
        42,
        2,
        43,
        7,
        43,
        2,
        44,
        7,
        44,
        2,
        45,
        7,
        45,
        2,
        46,
        7,
        46,
        2,
        47,
        7,
        47,
        2,
        48,
        7,
        48,
        2,
        49,
        7,
        49,
        2,
        50,
        7,
        50,
        2,
        51,
        7,
        51,
        2,
        52,
        7,
        52,
        2,
        53,
        7,
        53,
        2,
        54,
        7,
        54,
        2,
        55,
        7,
        55,
        2,
        56,
        7,
        56,
        2,
        57,
        7,
        57,
        2,
        58,
        7,
        58,
        2,
        59,
        7,
        59,
        2,
        60,
        7,
        60,
        2,
        61,
        7,
        61,
        2,
        62,
        7,
        62,
        2,
        63,
        7,
        63,
        2,
        64,
        7,
        64,
        2,
        65,
        7,
        65,
        2,
        66,
        7,
        66,
        2,
        67,
        7,
        67,
        2,
        68,
        7,
        68,
        2,
        69,
        7,
        69,
        2,
        70,
        7,
        70,
        2,
        71,
        7,
        71,
        2,
        72,
        7,
        72,
        2,
        73,
        7,
        73,
        2,
        74,
        7,
        74,
        2,
        75,
        7,
        75,
        2,
        76,
        7,
        76,
        2,
        77,
        7,
        77,
        2,
        78,
        7,
        78,
        2,
        79,
        7,
        79,
        2,
        80,
        7,
        80,
        2,
        81,
        7,
        81,
        2,
        82,
        7,
        82,
        2,
        83,
        7,
        83,
        2,
        84,
        7,
        84,
        2,
        85,
        7,
        85,
        2,
        86,
        7,
        86,
        2,
        87,
        7,
        87,
        2,
        88,
        7,
        88,
        2,
        89,
        7,
        89,
        2,
        90,
        7,
        90,
        2,
        91,
        7,
        91,
        2,
        92,
        7,
        92,
        2,
        93,
        7,
        93,
        2,
        94,
        7,
        94,
        2,
        95,
        7,
        95,
        2,
        96,
        7,
        96,
        2,
        97,
        7,
        97,
        2,
        98,
        7,
        98,
        2,
        99,
        7,
        99,
        2,
        100,
        7,
        100,
        2,
        101,
        7,
        101,
        2,
        102,
        7,
        102,
        2,
        103,
        7,
        103,
        2,
        104,
        7,
        104,
        2,
        105,
        7,
        105,
        2,
        106,
        7,
        106,
        2,
        107,
        7,
        107,
        2,
        108,
        7,
        108,
        2,
        109,
        7,
        109,
        2,
        110,
        7,
        110,
        2,
        111,
        7,
        111,
        2,
        112,
        7,
        112,
        2,
        113,
        7,
        113,
        2,
        114,
        7,
        114,
        2,
        115,
        7,
        115,
        2,
        116,
        7,
        116,
        2,
        117,
        7,
        117,
        2,
        118,
        7,
        118,
        2,
        119,
        7,
        119,
        2,
        120,
        7,
        120,
        2,
        121,
        7,
        121,
        2,
        122,
        7,
        122,
        2,
        123,
        7,
        123,
        2,
        124,
        7,
        124,
        2,
        125,
        7,
        125,
        2,
        126,
        7,
        126,
        2,
        127,
        7,
        127,
        2,
        128,
        7,
        128,
        2,
        129,
        7,
        129,
        2,
        130,
        7,
        130,
        2,
        131,
        7,
        131,
        2,
        132,
        7,
        132,
        2,
        133,
        7,
        133,
        2,
        134,
        7,
        134,
        2,
        135,
        7,
        135,
        2,
        136,
        7,
        136,
        2,
        137,
        7,
        137,
        1,
        0,
        5,
        0,
        278,
        8,
        0,
        10,
        0,
        12,
        0,
        281,
        9,
        0,
        1,
        0,
        5,
        0,
        284,
        8,
        0,
        10,
        0,
        12,
        0,
        287,
        9,
        0,
        1,
        0,
        1,
        0,
        1,
        1,
        1,
        1,
        1,
        2,
        1,
        2,
        1,
        2,
        1,
        2,
        1,
        2,
        3,
        2,
        298,
        8,
        2,
        1,
        3,
        1,
        3,
        3,
        3,
        302,
        8,
        3,
        1,
        4,
        1,
        4,
        1,
        4,
        1,
        4,
        1,
        4,
        1,
        4,
        5,
        4,
        310,
        8,
        4,
        10,
        4,
        12,
        4,
        313,
        9,
        4,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        1,
        5,
        3,
        5,
        326,
        8,
        5,
        1,
        6,
        1,
        6,
        1,
        6,
        1,
        6,
        1,
        6,
        1,
        6,
        1,
        7,
        1,
        7,
        1,
        8,
        1,
        8,
        1,
        9,
        1,
        9,
        1,
        9,
        1,
        9,
        1,
        9,
        1,
        10,
        1,
        10,
        1,
        10,
        1,
        10,
        1,
        10,
        1,
        10,
        1,
        10,
        1,
        10,
        1,
        11,
        1,
        11,
        1,
        12,
        1,
        12,
        1,
        12,
        1,
        12,
        1,
        12,
        3,
        12,
        358,
        8,
        12,
        1,
        12,
        1,
        12,
        3,
        12,
        362,
        8,
        12,
        1,
        12,
        1,
        12,
        1,
        13,
        1,
        13,
        1,
        13,
        5,
        13,
        369,
        8,
        13,
        10,
        13,
        12,
        13,
        372,
        9,
        13,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        14,
        1,
        15,
        1,
        15,
        1,
        15,
        1,
        15,
        3,
        15,
        383,
        8,
        15,
        1,
        16,
        1,
        16,
        1,
        16,
        1,
        16,
        3,
        16,
        389,
        8,
        16,
        1,
        17,
        1,
        17,
        1,
        17,
        1,
        17,
        1,
        17,
        1,
        17,
        1,
        17,
        5,
        17,
        398,
        8,
        17,
        10,
        17,
        12,
        17,
        401,
        9,
        17,
        1,
        17,
        1,
        17,
        1,
        17,
        1,
        18,
        1,
        18,
        1,
        18,
        3,
        18,
        409,
        8,
        18,
        1,
        19,
        1,
        19,
        1,
        20,
        1,
        20,
        1,
        21,
        1,
        21,
        1,
        22,
        1,
        22,
        1,
        22,
        1,
        22,
        1,
        23,
        1,
        23,
        1,
        23,
        1,
        23,
        1,
        23,
        3,
        23,
        426,
        8,
        23,
        1,
        23,
        1,
        23,
        1,
        24,
        1,
        24,
        1,
        24,
        3,
        24,
        433,
        8,
        24,
        1,
        24,
        1,
        24,
        1,
        24,
        1,
        24,
        4,
        24,
        439,
        8,
        24,
        11,
        24,
        12,
        24,
        440,
        1,
        24,
        1,
        24,
        1,
        24,
        3,
        24,
        446,
        8,
        24,
        1,
        25,
        1,
        25,
        1,
        25,
        3,
        25,
        451,
        8,
        25,
        1,
        26,
        1,
        26,
        1,
        26,
        1,
        26,
        1,
        26,
        3,
        26,
        458,
        8,
        26,
        1,
        27,
        1,
        27,
        1,
        28,
        1,
        28,
        1,
        29,
        1,
        29,
        1,
        29,
        3,
        29,
        467,
        8,
        29,
        1,
        29,
        1,
        29,
        1,
        29,
        1,
        29,
        4,
        29,
        473,
        8,
        29,
        11,
        29,
        12,
        29,
        474,
        1,
        29,
        1,
        29,
        1,
        29,
        3,
        29,
        480,
        8,
        29,
        1,
        30,
        1,
        30,
        1,
        30,
        3,
        30,
        485,
        8,
        30,
        1,
        31,
        1,
        31,
        1,
        31,
        1,
        31,
        1,
        31,
        3,
        31,
        492,
        8,
        31,
        1,
        32,
        1,
        32,
        1,
        33,
        1,
        33,
        1,
        33,
        3,
        33,
        499,
        8,
        33,
        1,
        33,
        1,
        33,
        1,
        33,
        1,
        33,
        1,
        33,
        4,
        33,
        506,
        8,
        33,
        11,
        33,
        12,
        33,
        507,
        1,
        33,
        1,
        33,
        1,
        33,
        3,
        33,
        513,
        8,
        33,
        1,
        34,
        1,
        34,
        1,
        34,
        3,
        34,
        518,
        8,
        34,
        1,
        35,
        1,
        35,
        1,
        35,
        1,
        35,
        1,
        35,
        1,
        35,
        3,
        35,
        526,
        8,
        35,
        1,
        36,
        1,
        36,
        1,
        36,
        3,
        36,
        531,
        8,
        36,
        1,
        36,
        1,
        36,
        1,
        37,
        1,
        37,
        1,
        38,
        1,
        38,
        1,
        38,
        3,
        38,
        540,
        8,
        38,
        1,
        38,
        1,
        38,
        1,
        38,
        1,
        38,
        1,
        38,
        4,
        38,
        547,
        8,
        38,
        11,
        38,
        12,
        38,
        548,
        1,
        38,
        1,
        38,
        1,
        38,
        3,
        38,
        554,
        8,
        38,
        1,
        39,
        1,
        39,
        1,
        39,
        3,
        39,
        559,
        8,
        39,
        1,
        40,
        1,
        40,
        1,
        40,
        1,
        40,
        3,
        40,
        565,
        8,
        40,
        1,
        40,
        1,
        40,
        1,
        40,
        3,
        40,
        570,
        8,
        40,
        1,
        40,
        1,
        40,
        1,
        40,
        1,
        40,
        4,
        40,
        576,
        8,
        40,
        11,
        40,
        12,
        40,
        577,
        1,
        40,
        1,
        40,
        1,
        40,
        3,
        40,
        583,
        8,
        40,
        1,
        41,
        1,
        41,
        1,
        42,
        1,
        42,
        3,
        42,
        589,
        8,
        42,
        1,
        43,
        1,
        43,
        1,
        43,
        1,
        43,
        1,
        43,
        1,
        43,
        1,
        43,
        5,
        43,
        598,
        8,
        43,
        10,
        43,
        12,
        43,
        601,
        9,
        43,
        1,
        43,
        1,
        43,
        1,
        43,
        1,
        44,
        1,
        44,
        1,
        44,
        1,
        44,
        1,
        44,
        1,
        44,
        4,
        44,
        612,
        8,
        44,
        11,
        44,
        12,
        44,
        613,
        1,
        44,
        1,
        44,
        1,
        45,
        1,
        45,
        3,
        45,
        620,
        8,
        45,
        1,
        46,
        1,
        46,
        1,
        46,
        1,
        46,
        3,
        46,
        626,
        8,
        46,
        1,
        47,
        1,
        47,
        1,
        47,
        1,
        47,
        5,
        47,
        632,
        8,
        47,
        10,
        47,
        12,
        47,
        635,
        9,
        47,
        1,
        47,
        1,
        47,
        1,
        47,
        1,
        47,
        3,
        47,
        641,
        8,
        47,
        1,
        47,
        1,
        47,
        3,
        47,
        645,
        8,
        47,
        1,
        48,
        1,
        48,
        3,
        48,
        649,
        8,
        48,
        1,
        49,
        1,
        49,
        1,
        49,
        3,
        49,
        654,
        8,
        49,
        1,
        50,
        1,
        50,
        1,
        51,
        1,
        51,
        1,
        51,
        1,
        51,
        1,
        52,
        1,
        52,
        1,
        53,
        1,
        53,
        1,
        54,
        1,
        54,
        1,
        54,
        1,
        54,
        1,
        54,
        1,
        54,
        3,
        54,
        672,
        8,
        54,
        1,
        54,
        1,
        54,
        3,
        54,
        676,
        8,
        54,
        1,
        54,
        1,
        54,
        1,
        55,
        1,
        55,
        3,
        55,
        682,
        8,
        55,
        1,
        55,
        1,
        55,
        3,
        55,
        686,
        8,
        55,
        1,
        55,
        3,
        55,
        689,
        8,
        55,
        1,
        56,
        1,
        56,
        1,
        56,
        1,
        57,
        1,
        57,
        1,
        57,
        1,
        58,
        1,
        58,
        1,
        59,
        1,
        59,
        1,
        60,
        1,
        60,
        1,
        60,
        3,
        60,
        704,
        8,
        60,
        1,
        60,
        1,
        60,
        1,
        61,
        1,
        61,
        1,
        61,
        1,
        61,
        1,
        61,
        3,
        61,
        713,
        8,
        61,
        1,
        62,
        1,
        62,
        1,
        62,
        1,
        62,
        1,
        62,
        1,
        63,
        1,
        63,
        1,
        63,
        1,
        63,
        1,
        63,
        1,
        64,
        1,
        64,
        1,
        64,
        1,
        64,
        1,
        64,
        1,
        65,
        1,
        65,
        1,
        65,
        1,
        65,
        1,
        65,
        1,
        65,
        1,
        65,
        1,
        65,
        3,
        65,
        738,
        8,
        65,
        1,
        65,
        1,
        65,
        1,
        66,
        1,
        66,
        1,
        67,
        1,
        67,
        1,
        68,
        1,
        68,
        3,
        68,
        748,
        8,
        68,
        1,
        69,
        1,
        69,
        1,
        69,
        5,
        69,
        753,
        8,
        69,
        10,
        69,
        12,
        69,
        756,
        9,
        69,
        1,
        69,
        1,
        69,
        1,
        69,
        1,
        69,
        3,
        69,
        762,
        8,
        69,
        1,
        69,
        1,
        69,
        3,
        69,
        766,
        8,
        69,
        1,
        70,
        1,
        70,
        1,
        70,
        1,
        70,
        5,
        70,
        772,
        8,
        70,
        10,
        70,
        12,
        70,
        775,
        9,
        70,
        1,
        70,
        1,
        70,
        1,
        70,
        1,
        70,
        1,
        70,
        3,
        70,
        782,
        8,
        70,
        3,
        70,
        784,
        8,
        70,
        1,
        70,
        1,
        70,
        1,
        71,
        1,
        71,
        1,
        71,
        1,
        71,
        1,
        71,
        1,
        71,
        1,
        71,
        3,
        71,
        795,
        8,
        71,
        1,
        71,
        1,
        71,
        1,
        72,
        1,
        72,
        1,
        73,
        1,
        73,
        1,
        73,
        1,
        73,
        1,
        73,
        4,
        73,
        806,
        8,
        73,
        11,
        73,
        12,
        73,
        807,
        1,
        73,
        1,
        73,
        1,
        74,
        1,
        74,
        3,
        74,
        814,
        8,
        74,
        1,
        75,
        1,
        75,
        3,
        75,
        818,
        8,
        75,
        1,
        76,
        1,
        76,
        1,
        76,
        3,
        76,
        823,
        8,
        76,
        1,
        76,
        1,
        76,
        1,
        76,
        1,
        76,
        1,
        77,
        1,
        77,
        1,
        78,
        1,
        78,
        1,
        79,
        1,
        79,
        1,
        79,
        1,
        79,
        1,
        79,
        1,
        79,
        1,
        80,
        1,
        80,
        3,
        80,
        841,
        8,
        80,
        1,
        81,
        1,
        81,
        3,
        81,
        845,
        8,
        81,
        1,
        81,
        1,
        81,
        3,
        81,
        849,
        8,
        81,
        1,
        81,
        1,
        81,
        1,
        81,
        3,
        81,
        854,
        8,
        81,
        1,
        81,
        1,
        81,
        1,
        81,
        1,
        82,
        1,
        82,
        1,
        82,
        1,
        82,
        1,
        82,
        1,
        83,
        1,
        83,
        3,
        83,
        866,
        8,
        83,
        1,
        84,
        1,
        84,
        1,
        84,
        1,
        84,
        1,
        84,
        1,
        84,
        4,
        84,
        874,
        8,
        84,
        11,
        84,
        12,
        84,
        875,
        1,
        84,
        1,
        84,
        1,
        85,
        1,
        85,
        3,
        85,
        882,
        8,
        85,
        1,
        86,
        1,
        86,
        1,
        86,
        1,
        87,
        1,
        87,
        1,
        87,
        3,
        87,
        890,
        8,
        87,
        1,
        87,
        1,
        87,
        1,
        87,
        1,
        87,
        1,
        87,
        3,
        87,
        897,
        8,
        87,
        1,
        88,
        1,
        88,
        1,
        88,
        3,
        88,
        902,
        8,
        88,
        1,
        88,
        3,
        88,
        905,
        8,
        88,
        1,
        88,
        1,
        88,
        1,
        88,
        1,
        88,
        4,
        88,
        911,
        8,
        88,
        11,
        88,
        12,
        88,
        912,
        1,
        88,
        1,
        88,
        3,
        88,
        917,
        8,
        88,
        1,
        89,
        1,
        89,
        1,
        90,
        1,
        90,
        1,
        90,
        3,
        90,
        924,
        8,
        90,
        1,
        90,
        1,
        90,
        1,
        90,
        3,
        90,
        929,
        8,
        90,
        1,
        90,
        1,
        90,
        1,
        90,
        3,
        90,
        934,
        8,
        90,
        1,
        91,
        1,
        91,
        1,
        91,
        1,
        91,
        1,
        91,
        4,
        91,
        941,
        8,
        91,
        11,
        91,
        12,
        91,
        942,
        1,
        91,
        1,
        91,
        1,
        92,
        1,
        92,
        1,
        92,
        3,
        92,
        950,
        8,
        92,
        1,
        93,
        1,
        93,
        1,
        94,
        1,
        94,
        1,
        95,
        1,
        95,
        1,
        95,
        1,
        95,
        1,
        96,
        1,
        96,
        1,
        96,
        1,
        96,
        1,
        96,
        1,
        96,
        3,
        96,
        966,
        8,
        96,
        1,
        96,
        1,
        96,
        1,
        97,
        1,
        97,
        1,
        97,
        1,
        97,
        1,
        98,
        1,
        98,
        1,
        98,
        1,
        98,
        1,
        99,
        1,
        99,
        1,
        99,
        3,
        99,
        981,
        8,
        99,
        1,
        99,
        1,
        99,
        1,
        100,
        1,
        100,
        1,
        100,
        1,
        100,
        3,
        100,
        989,
        8,
        100,
        1,
        100,
        1,
        100,
        1,
        100,
        3,
        100,
        994,
        8,
        100,
        1,
        100,
        1,
        100,
        1,
        100,
        1,
        101,
        1,
        101,
        1,
        102,
        1,
        102,
        3,
        102,
        1003,
        8,
        102,
        1,
        102,
        1,
        102,
        1,
        102,
        1,
        102,
        1,
        102,
        1,
        102,
        1,
        102,
        3,
        102,
        1012,
        8,
        102,
        1,
        102,
        1,
        102,
        3,
        102,
        1016,
        8,
        102,
        1,
        103,
        1,
        103,
        1,
        104,
        1,
        104,
        1,
        105,
        1,
        105,
        3,
        105,
        1024,
        8,
        105,
        1,
        106,
        1,
        106,
        1,
        106,
        3,
        106,
        1029,
        8,
        106,
        1,
        106,
        5,
        106,
        1032,
        8,
        106,
        10,
        106,
        12,
        106,
        1035,
        9,
        106,
        1,
        106,
        1,
        106,
        1,
        106,
        1,
        107,
        1,
        107,
        1,
        107,
        3,
        107,
        1043,
        8,
        107,
        1,
        107,
        5,
        107,
        1046,
        8,
        107,
        10,
        107,
        12,
        107,
        1049,
        9,
        107,
        1,
        107,
        1,
        107,
        1,
        107,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        1,
        108,
        3,
        108,
        1076,
        8,
        108,
        1,
        109,
        1,
        109,
        1,
        110,
        1,
        110,
        3,
        110,
        1082,
        8,
        110,
        1,
        111,
        1,
        111,
        1,
        111,
        1,
        111,
        1,
        111,
        1,
        111,
        1,
        112,
        1,
        112,
        1,
        112,
        5,
        112,
        1093,
        8,
        112,
        10,
        112,
        12,
        112,
        1096,
        9,
        112,
        1,
        113,
        1,
        113,
        1,
        113,
        5,
        113,
        1101,
        8,
        113,
        10,
        113,
        12,
        113,
        1104,
        9,
        113,
        1,
        114,
        1,
        114,
        1,
        114,
        5,
        114,
        1109,
        8,
        114,
        10,
        114,
        12,
        114,
        1112,
        9,
        114,
        1,
        115,
        1,
        115,
        1,
        115,
        3,
        115,
        1117,
        8,
        115,
        1,
        116,
        1,
        116,
        1,
        116,
        1,
        116,
        1,
        116,
        1,
        116,
        1,
        116,
        5,
        116,
        1126,
        8,
        116,
        10,
        116,
        12,
        116,
        1129,
        9,
        116,
        1,
        117,
        1,
        117,
        1,
        118,
        1,
        118,
        1,
        118,
        1,
        118,
        1,
        118,
        1,
        118,
        1,
        118,
        5,
        118,
        1140,
        8,
        118,
        10,
        118,
        12,
        118,
        1143,
        9,
        118,
        1,
        119,
        1,
        119,
        1,
        120,
        1,
        120,
        1,
        120,
        1,
        120,
        1,
        120,
        1,
        120,
        1,
        120,
        5,
        120,
        1154,
        8,
        120,
        10,
        120,
        12,
        120,
        1157,
        9,
        120,
        1,
        121,
        1,
        121,
        1,
        122,
        1,
        122,
        1,
        122,
        3,
        122,
        1164,
        8,
        122,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        3,
        123,
        1191,
        8,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        1,
        123,
        5,
        123,
        1197,
        8,
        123,
        10,
        123,
        12,
        123,
        1200,
        9,
        123,
        1,
        124,
        1,
        124,
        1,
        124,
        1,
        124,
        1,
        125,
        1,
        125,
        1,
        125,
        1,
        125,
        1,
        125,
        1,
        125,
        1,
        125,
        3,
        125,
        1213,
        8,
        125,
        1,
        126,
        1,
        126,
        1,
        126,
        1,
        126,
        1,
        126,
        1,
        126,
        1,
        126,
        1,
        126,
        1,
        126,
        3,
        126,
        1224,
        8,
        126,
        1,
        127,
        1,
        127,
        1,
        127,
        1,
        127,
        5,
        127,
        1230,
        8,
        127,
        10,
        127,
        12,
        127,
        1233,
        9,
        127,
        1,
        127,
        1,
        127,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        1,
        128,
        3,
        128,
        1250,
        8,
        128,
        1,
        129,
        1,
        129,
        1,
        129,
        5,
        129,
        1255,
        8,
        129,
        10,
        129,
        12,
        129,
        1258,
        9,
        129,
        1,
        129,
        1,
        129,
        1,
        130,
        1,
        130,
        1,
        130,
        5,
        130,
        1265,
        8,
        130,
        10,
        130,
        12,
        130,
        1268,
        9,
        130,
        1,
        131,
        1,
        131,
        1,
        131,
        1,
        131,
        1,
        131,
        3,
        131,
        1275,
        8,
        131,
        1,
        132,
        1,
        132,
        1,
        133,
        1,
        133,
        1,
        133,
        5,
        133,
        1282,
        8,
        133,
        10,
        133,
        12,
        133,
        1285,
        9,
        133,
        1,
        133,
        1,
        133,
        5,
        133,
        1289,
        8,
        133,
        10,
        133,
        12,
        133,
        1292,
        9,
        133,
        1,
        133,
        1,
        133,
        1,
        133,
        5,
        133,
        1297,
        8,
        133,
        10,
        133,
        12,
        133,
        1300,
        9,
        133,
        3,
        133,
        1302,
        8,
        133,
        1,
        134,
        1,
        134,
        1,
        135,
        1,
        135,
        1,
        135,
        1,
        135,
        1,
        136,
        1,
        136,
        3,
        136,
        1312,
        8,
        136,
        1,
        136,
        1,
        136,
        1,
        137,
        1,
        137,
        1,
        137,
        0,
        5,
        8,
        232,
        236,
        240,
        246,
        138,
        0,
        2,
        4,
        6,
        8,
        10,
        12,
        14,
        16,
        18,
        20,
        22,
        24,
        26,
        28,
        30,
        32,
        34,
        36,
        38,
        40,
        42,
        44,
        46,
        48,
        50,
        52,
        54,
        56,
        58,
        60,
        62,
        64,
        66,
        68,
        70,
        72,
        74,
        76,
        78,
        80,
        82,
        84,
        86,
        88,
        90,
        92,
        94,
        96,
        98,
        100,
        102,
        104,
        106,
        108,
        110,
        112,
        114,
        116,
        118,
        120,
        122,
        124,
        126,
        128,
        130,
        132,
        134,
        136,
        138,
        140,
        142,
        144,
        146,
        148,
        150,
        152,
        154,
        156,
        158,
        160,
        162,
        164,
        166,
        168,
        170,
        172,
        174,
        176,
        178,
        180,
        182,
        184,
        186,
        188,
        190,
        192,
        194,
        196,
        198,
        200,
        202,
        204,
        206,
        208,
        210,
        212,
        214,
        216,
        218,
        220,
        222,
        224,
        226,
        228,
        230,
        232,
        234,
        236,
        238,
        240,
        242,
        244,
        246,
        248,
        250,
        252,
        254,
        256,
        258,
        260,
        262,
        264,
        266,
        268,
        270,
        272,
        274,
        0,
        8,
        1,
        0,
        89,
        90,
        1,
        0,
        23,
        27,
        1,
        0,
        40,
        41,
        1,
        0,
        45,
        47,
        2,
        0,
        13,
        13,
        66,
        71,
        1,
        0,
        72,
        73,
        1,
        0,
        74,
        76,
        1,
        0,
        89,
        91,
        1350,
        0,
        279,
        1,
        0,
        0,
        0,
        2,
        290,
        1,
        0,
        0,
        0,
        4,
        297,
        1,
        0,
        0,
        0,
        6,
        301,
        1,
        0,
        0,
        0,
        8,
        303,
        1,
        0,
        0,
        0,
        10,
        325,
        1,
        0,
        0,
        0,
        12,
        327,
        1,
        0,
        0,
        0,
        14,
        333,
        1,
        0,
        0,
        0,
        16,
        335,
        1,
        0,
        0,
        0,
        18,
        337,
        1,
        0,
        0,
        0,
        20,
        342,
        1,
        0,
        0,
        0,
        22,
        350,
        1,
        0,
        0,
        0,
        24,
        352,
        1,
        0,
        0,
        0,
        26,
        365,
        1,
        0,
        0,
        0,
        28,
        373,
        1,
        0,
        0,
        0,
        30,
        378,
        1,
        0,
        0,
        0,
        32,
        384,
        1,
        0,
        0,
        0,
        34,
        390,
        1,
        0,
        0,
        0,
        36,
        405,
        1,
        0,
        0,
        0,
        38,
        410,
        1,
        0,
        0,
        0,
        40,
        412,
        1,
        0,
        0,
        0,
        42,
        414,
        1,
        0,
        0,
        0,
        44,
        416,
        1,
        0,
        0,
        0,
        46,
        420,
        1,
        0,
        0,
        0,
        48,
        429,
        1,
        0,
        0,
        0,
        50,
        447,
        1,
        0,
        0,
        0,
        52,
        457,
        1,
        0,
        0,
        0,
        54,
        459,
        1,
        0,
        0,
        0,
        56,
        461,
        1,
        0,
        0,
        0,
        58,
        463,
        1,
        0,
        0,
        0,
        60,
        481,
        1,
        0,
        0,
        0,
        62,
        491,
        1,
        0,
        0,
        0,
        64,
        493,
        1,
        0,
        0,
        0,
        66,
        495,
        1,
        0,
        0,
        0,
        68,
        514,
        1,
        0,
        0,
        0,
        70,
        525,
        1,
        0,
        0,
        0,
        72,
        530,
        1,
        0,
        0,
        0,
        74,
        534,
        1,
        0,
        0,
        0,
        76,
        536,
        1,
        0,
        0,
        0,
        78,
        555,
        1,
        0,
        0,
        0,
        80,
        560,
        1,
        0,
        0,
        0,
        82,
        584,
        1,
        0,
        0,
        0,
        84,
        588,
        1,
        0,
        0,
        0,
        86,
        590,
        1,
        0,
        0,
        0,
        88,
        605,
        1,
        0,
        0,
        0,
        90,
        619,
        1,
        0,
        0,
        0,
        92,
        625,
        1,
        0,
        0,
        0,
        94,
        627,
        1,
        0,
        0,
        0,
        96,
        648,
        1,
        0,
        0,
        0,
        98,
        653,
        1,
        0,
        0,
        0,
        100,
        655,
        1,
        0,
        0,
        0,
        102,
        657,
        1,
        0,
        0,
        0,
        104,
        661,
        1,
        0,
        0,
        0,
        106,
        663,
        1,
        0,
        0,
        0,
        108,
        665,
        1,
        0,
        0,
        0,
        110,
        688,
        1,
        0,
        0,
        0,
        112,
        690,
        1,
        0,
        0,
        0,
        114,
        693,
        1,
        0,
        0,
        0,
        116,
        696,
        1,
        0,
        0,
        0,
        118,
        698,
        1,
        0,
        0,
        0,
        120,
        703,
        1,
        0,
        0,
        0,
        122,
        712,
        1,
        0,
        0,
        0,
        124,
        714,
        1,
        0,
        0,
        0,
        126,
        719,
        1,
        0,
        0,
        0,
        128,
        724,
        1,
        0,
        0,
        0,
        130,
        729,
        1,
        0,
        0,
        0,
        132,
        741,
        1,
        0,
        0,
        0,
        134,
        743,
        1,
        0,
        0,
        0,
        136,
        747,
        1,
        0,
        0,
        0,
        138,
        749,
        1,
        0,
        0,
        0,
        140,
        767,
        1,
        0,
        0,
        0,
        142,
        787,
        1,
        0,
        0,
        0,
        144,
        798,
        1,
        0,
        0,
        0,
        146,
        800,
        1,
        0,
        0,
        0,
        148,
        813,
        1,
        0,
        0,
        0,
        150,
        817,
        1,
        0,
        0,
        0,
        152,
        819,
        1,
        0,
        0,
        0,
        154,
        828,
        1,
        0,
        0,
        0,
        156,
        830,
        1,
        0,
        0,
        0,
        158,
        832,
        1,
        0,
        0,
        0,
        160,
        840,
        1,
        0,
        0,
        0,
        162,
        848,
        1,
        0,
        0,
        0,
        164,
        858,
        1,
        0,
        0,
        0,
        166,
        865,
        1,
        0,
        0,
        0,
        168,
        867,
        1,
        0,
        0,
        0,
        170,
        881,
        1,
        0,
        0,
        0,
        172,
        883,
        1,
        0,
        0,
        0,
        174,
        889,
        1,
        0,
        0,
        0,
        176,
        898,
        1,
        0,
        0,
        0,
        178,
        918,
        1,
        0,
        0,
        0,
        180,
        923,
        1,
        0,
        0,
        0,
        182,
        935,
        1,
        0,
        0,
        0,
        184,
        949,
        1,
        0,
        0,
        0,
        186,
        951,
        1,
        0,
        0,
        0,
        188,
        953,
        1,
        0,
        0,
        0,
        190,
        955,
        1,
        0,
        0,
        0,
        192,
        959,
        1,
        0,
        0,
        0,
        194,
        969,
        1,
        0,
        0,
        0,
        196,
        973,
        1,
        0,
        0,
        0,
        198,
        977,
        1,
        0,
        0,
        0,
        200,
        984,
        1,
        0,
        0,
        0,
        202,
        998,
        1,
        0,
        0,
        0,
        204,
        1000,
        1,
        0,
        0,
        0,
        206,
        1017,
        1,
        0,
        0,
        0,
        208,
        1019,
        1,
        0,
        0,
        0,
        210,
        1023,
        1,
        0,
        0,
        0,
        212,
        1025,
        1,
        0,
        0,
        0,
        214,
        1039,
        1,
        0,
        0,
        0,
        216,
        1075,
        1,
        0,
        0,
        0,
        218,
        1077,
        1,
        0,
        0,
        0,
        220,
        1081,
        1,
        0,
        0,
        0,
        222,
        1083,
        1,
        0,
        0,
        0,
        224,
        1089,
        1,
        0,
        0,
        0,
        226,
        1097,
        1,
        0,
        0,
        0,
        228,
        1105,
        1,
        0,
        0,
        0,
        230,
        1116,
        1,
        0,
        0,
        0,
        232,
        1118,
        1,
        0,
        0,
        0,
        234,
        1130,
        1,
        0,
        0,
        0,
        236,
        1132,
        1,
        0,
        0,
        0,
        238,
        1144,
        1,
        0,
        0,
        0,
        240,
        1146,
        1,
        0,
        0,
        0,
        242,
        1158,
        1,
        0,
        0,
        0,
        244,
        1163,
        1,
        0,
        0,
        0,
        246,
        1165,
        1,
        0,
        0,
        0,
        248,
        1201,
        1,
        0,
        0,
        0,
        250,
        1212,
        1,
        0,
        0,
        0,
        252,
        1223,
        1,
        0,
        0,
        0,
        254,
        1225,
        1,
        0,
        0,
        0,
        256,
        1249,
        1,
        0,
        0,
        0,
        258,
        1256,
        1,
        0,
        0,
        0,
        260,
        1261,
        1,
        0,
        0,
        0,
        262,
        1269,
        1,
        0,
        0,
        0,
        264,
        1276,
        1,
        0,
        0,
        0,
        266,
        1301,
        1,
        0,
        0,
        0,
        268,
        1303,
        1,
        0,
        0,
        0,
        270,
        1305,
        1,
        0,
        0,
        0,
        272,
        1311,
        1,
        0,
        0,
        0,
        274,
        1315,
        1,
        0,
        0,
        0,
        276,
        278,
        3,
        2,
        1,
        0,
        277,
        276,
        1,
        0,
        0,
        0,
        278,
        281,
        1,
        0,
        0,
        0,
        279,
        277,
        1,
        0,
        0,
        0,
        279,
        280,
        1,
        0,
        0,
        0,
        280,
        285,
        1,
        0,
        0,
        0,
        281,
        279,
        1,
        0,
        0,
        0,
        282,
        284,
        3,
        10,
        5,
        0,
        283,
        282,
        1,
        0,
        0,
        0,
        284,
        287,
        1,
        0,
        0,
        0,
        285,
        283,
        1,
        0,
        0,
        0,
        285,
        286,
        1,
        0,
        0,
        0,
        286,
        288,
        1,
        0,
        0,
        0,
        287,
        285,
        1,
        0,
        0,
        0,
        288,
        289,
        5,
        0,
        0,
        1,
        289,
        1,
        1,
        0,
        0,
        0,
        290,
        291,
        3,
        4,
        2,
        0,
        291,
        3,
        1,
        0,
        0,
        0,
        292,
        293,
        5,
        1,
        0,
        0,
        293,
        294,
        3,
        6,
        3,
        0,
        294,
        295,
        5,
        79,
        0,
        0,
        295,
        298,
        1,
        0,
        0,
        0,
        296,
        298,
        5,
        79,
        0,
        0,
        297,
        292,
        1,
        0,
        0,
        0,
        297,
        296,
        1,
        0,
        0,
        0,
        298,
        5,
        1,
        0,
        0,
        0,
        299,
        302,
        5,
        87,
        0,
        0,
        300,
        302,
        3,
        8,
        4,
        0,
        301,
        299,
        1,
        0,
        0,
        0,
        301,
        300,
        1,
        0,
        0,
        0,
        302,
        7,
        1,
        0,
        0,
        0,
        303,
        304,
        6,
        4,
        -1,
        0,
        304,
        305,
        5,
        93,
        0,
        0,
        305,
        311,
        1,
        0,
        0,
        0,
        306,
        307,
        10,
        1,
        0,
        0,
        307,
        308,
        5,
        2,
        0,
        0,
        308,
        310,
        5,
        93,
        0,
        0,
        309,
        306,
        1,
        0,
        0,
        0,
        310,
        313,
        1,
        0,
        0,
        0,
        311,
        309,
        1,
        0,
        0,
        0,
        311,
        312,
        1,
        0,
        0,
        0,
        312,
        9,
        1,
        0,
        0,
        0,
        313,
        311,
        1,
        0,
        0,
        0,
        314,
        326,
        3,
        12,
        6,
        0,
        315,
        326,
        3,
        20,
        10,
        0,
        316,
        326,
        3,
        34,
        17,
        0,
        317,
        326,
        3,
        48,
        24,
        0,
        318,
        326,
        3,
        58,
        29,
        0,
        319,
        326,
        3,
        76,
        38,
        0,
        320,
        326,
        3,
        66,
        33,
        0,
        321,
        326,
        3,
        80,
        40,
        0,
        322,
        326,
        3,
        84,
        42,
        0,
        323,
        326,
        3,
        94,
        47,
        0,
        324,
        326,
        5,
        79,
        0,
        0,
        325,
        314,
        1,
        0,
        0,
        0,
        325,
        315,
        1,
        0,
        0,
        0,
        325,
        316,
        1,
        0,
        0,
        0,
        325,
        317,
        1,
        0,
        0,
        0,
        325,
        318,
        1,
        0,
        0,
        0,
        325,
        319,
        1,
        0,
        0,
        0,
        325,
        320,
        1,
        0,
        0,
        0,
        325,
        321,
        1,
        0,
        0,
        0,
        325,
        322,
        1,
        0,
        0,
        0,
        325,
        323,
        1,
        0,
        0,
        0,
        325,
        324,
        1,
        0,
        0,
        0,
        326,
        11,
        1,
        0,
        0,
        0,
        327,
        328,
        5,
        3,
        0,
        0,
        328,
        329,
        3,
        14,
        7,
        0,
        329,
        330,
        5,
        4,
        0,
        0,
        330,
        331,
        3,
        16,
        8,
        0,
        331,
        332,
        5,
        79,
        0,
        0,
        332,
        13,
        1,
        0,
        0,
        0,
        333,
        334,
        5,
        93,
        0,
        0,
        334,
        15,
        1,
        0,
        0,
        0,
        335,
        336,
        3,
        18,
        9,
        0,
        336,
        17,
        1,
        0,
        0,
        0,
        337,
        338,
        5,
        5,
        0,
        0,
        338,
        339,
        5,
        82,
        0,
        0,
        339,
        340,
        3,
        26,
        13,
        0,
        340,
        341,
        5,
        83,
        0,
        0,
        341,
        19,
        1,
        0,
        0,
        0,
        342,
        343,
        5,
        6,
        0,
        0,
        343,
        344,
        5,
        93,
        0,
        0,
        344,
        345,
        5,
        7,
        0,
        0,
        345,
        346,
        3,
        14,
        7,
        0,
        346,
        347,
        5,
        4,
        0,
        0,
        347,
        348,
        3,
        22,
        11,
        0,
        348,
        349,
        5,
        79,
        0,
        0,
        349,
        21,
        1,
        0,
        0,
        0,
        350,
        351,
        3,
        24,
        12,
        0,
        351,
        23,
        1,
        0,
        0,
        0,
        352,
        353,
        5,
        5,
        0,
        0,
        353,
        354,
        5,
        82,
        0,
        0,
        354,
        357,
        3,
        26,
        13,
        0,
        355,
        356,
        5,
        8,
        0,
        0,
        356,
        358,
        3,
        30,
        15,
        0,
        357,
        355,
        1,
        0,
        0,
        0,
        357,
        358,
        1,
        0,
        0,
        0,
        358,
        361,
        1,
        0,
        0,
        0,
        359,
        360,
        5,
        8,
        0,
        0,
        360,
        362,
        3,
        32,
        16,
        0,
        361,
        359,
        1,
        0,
        0,
        0,
        361,
        362,
        1,
        0,
        0,
        0,
        362,
        363,
        1,
        0,
        0,
        0,
        363,
        364,
        5,
        83,
        0,
        0,
        364,
        25,
        1,
        0,
        0,
        0,
        365,
        370,
        3,
        28,
        14,
        0,
        366,
        367,
        5,
        8,
        0,
        0,
        367,
        369,
        3,
        28,
        14,
        0,
        368,
        366,
        1,
        0,
        0,
        0,
        369,
        372,
        1,
        0,
        0,
        0,
        370,
        368,
        1,
        0,
        0,
        0,
        370,
        371,
        1,
        0,
        0,
        0,
        371,
        27,
        1,
        0,
        0,
        0,
        372,
        370,
        1,
        0,
        0,
        0,
        373,
        374,
        5,
        93,
        0,
        0,
        374,
        375,
        6,
        14,
        -1,
        0,
        375,
        376,
        5,
        9,
        0,
        0,
        376,
        377,
        3,
        274,
        137,
        0,
        377,
        29,
        1,
        0,
        0,
        0,
        378,
        379,
        5,
        93,
        0,
        0,
        379,
        382,
        5,
        9,
        0,
        0,
        380,
        383,
        5,
        88,
        0,
        0,
        381,
        383,
        3,
        274,
        137,
        0,
        382,
        380,
        1,
        0,
        0,
        0,
        382,
        381,
        1,
        0,
        0,
        0,
        383,
        31,
        1,
        0,
        0,
        0,
        384,
        385,
        5,
        93,
        0,
        0,
        385,
        388,
        5,
        9,
        0,
        0,
        386,
        389,
        5,
        88,
        0,
        0,
        387,
        389,
        3,
        274,
        137,
        0,
        388,
        386,
        1,
        0,
        0,
        0,
        388,
        387,
        1,
        0,
        0,
        0,
        389,
        33,
        1,
        0,
        0,
        0,
        390,
        391,
        5,
        10,
        0,
        0,
        391,
        392,
        3,
        40,
        20,
        0,
        392,
        393,
        5,
        9,
        0,
        0,
        393,
        394,
        5,
        80,
        0,
        0,
        394,
        399,
        3,
        36,
        18,
        0,
        395,
        396,
        5,
        8,
        0,
        0,
        396,
        398,
        3,
        36,
        18,
        0,
        397,
        395,
        1,
        0,
        0,
        0,
        398,
        401,
        1,
        0,
        0,
        0,
        399,
        397,
        1,
        0,
        0,
        0,
        399,
        400,
        1,
        0,
        0,
        0,
        400,
        402,
        1,
        0,
        0,
        0,
        401,
        399,
        1,
        0,
        0,
        0,
        402,
        403,
        5,
        81,
        0,
        0,
        403,
        404,
        5,
        79,
        0,
        0,
        404,
        35,
        1,
        0,
        0,
        0,
        405,
        408,
        3,
        42,
        21,
        0,
        406,
        407,
        5,
        11,
        0,
        0,
        407,
        409,
        3,
        38,
        19,
        0,
        408,
        406,
        1,
        0,
        0,
        0,
        408,
        409,
        1,
        0,
        0,
        0,
        409,
        37,
        1,
        0,
        0,
        0,
        410,
        411,
        7,
        0,
        0,
        0,
        411,
        39,
        1,
        0,
        0,
        0,
        412,
        413,
        5,
        93,
        0,
        0,
        413,
        41,
        1,
        0,
        0,
        0,
        414,
        415,
        5,
        93,
        0,
        0,
        415,
        43,
        1,
        0,
        0,
        0,
        416,
        417,
        3,
        40,
        20,
        0,
        417,
        418,
        5,
        12,
        0,
        0,
        418,
        419,
        3,
        42,
        21,
        0,
        419,
        45,
        1,
        0,
        0,
        0,
        420,
        421,
        5,
        82,
        0,
        0,
        421,
        422,
        3,
        54,
        27,
        0,
        422,
        425,
        5,
        13,
        0,
        0,
        423,
        426,
        3,
        44,
        22,
        0,
        424,
        426,
        5,
        92,
        0,
        0,
        425,
        423,
        1,
        0,
        0,
        0,
        425,
        424,
        1,
        0,
        0,
        0,
        426,
        427,
        1,
        0,
        0,
        0,
        427,
        428,
        5,
        83,
        0,
        0,
        428,
        47,
        1,
        0,
        0,
        0,
        429,
        430,
        5,
        14,
        0,
        0,
        430,
        432,
        3,
        56,
        28,
        0,
        431,
        433,
        3,
        50,
        25,
        0,
        432,
        431,
        1,
        0,
        0,
        0,
        432,
        433,
        1,
        0,
        0,
        0,
        433,
        445,
        1,
        0,
        0,
        0,
        434,
        435,
        5,
        9,
        0,
        0,
        435,
        436,
        5,
        79,
        0,
        0,
        436,
        438,
        5,
        94,
        0,
        0,
        437,
        439,
        3,
        52,
        26,
        0,
        438,
        437,
        1,
        0,
        0,
        0,
        439,
        440,
        1,
        0,
        0,
        0,
        440,
        438,
        1,
        0,
        0,
        0,
        440,
        441,
        1,
        0,
        0,
        0,
        441,
        442,
        1,
        0,
        0,
        0,
        442,
        443,
        5,
        95,
        0,
        0,
        443,
        446,
        1,
        0,
        0,
        0,
        444,
        446,
        5,
        79,
        0,
        0,
        445,
        434,
        1,
        0,
        0,
        0,
        445,
        444,
        1,
        0,
        0,
        0,
        446,
        49,
        1,
        0,
        0,
        0,
        447,
        448,
        5,
        15,
        0,
        0,
        448,
        450,
        3,
        56,
        28,
        0,
        449,
        451,
        3,
        46,
        23,
        0,
        450,
        449,
        1,
        0,
        0,
        0,
        450,
        451,
        1,
        0,
        0,
        0,
        451,
        51,
        1,
        0,
        0,
        0,
        452,
        458,
        3,
        108,
        54,
        0,
        453,
        458,
        3,
        136,
        68,
        0,
        454,
        458,
        3,
        150,
        75,
        0,
        455,
        458,
        3,
        200,
        100,
        0,
        456,
        458,
        3,
        210,
        105,
        0,
        457,
        452,
        1,
        0,
        0,
        0,
        457,
        453,
        1,
        0,
        0,
        0,
        457,
        454,
        1,
        0,
        0,
        0,
        457,
        455,
        1,
        0,
        0,
        0,
        457,
        456,
        1,
        0,
        0,
        0,
        458,
        53,
        1,
        0,
        0,
        0,
        459,
        460,
        5,
        93,
        0,
        0,
        460,
        55,
        1,
        0,
        0,
        0,
        461,
        462,
        5,
        93,
        0,
        0,
        462,
        57,
        1,
        0,
        0,
        0,
        463,
        464,
        5,
        16,
        0,
        0,
        464,
        466,
        3,
        64,
        32,
        0,
        465,
        467,
        3,
        60,
        30,
        0,
        466,
        465,
        1,
        0,
        0,
        0,
        466,
        467,
        1,
        0,
        0,
        0,
        467,
        479,
        1,
        0,
        0,
        0,
        468,
        469,
        5,
        9,
        0,
        0,
        469,
        470,
        5,
        79,
        0,
        0,
        470,
        472,
        5,
        94,
        0,
        0,
        471,
        473,
        3,
        62,
        31,
        0,
        472,
        471,
        1,
        0,
        0,
        0,
        473,
        474,
        1,
        0,
        0,
        0,
        474,
        472,
        1,
        0,
        0,
        0,
        474,
        475,
        1,
        0,
        0,
        0,
        475,
        476,
        1,
        0,
        0,
        0,
        476,
        477,
        5,
        95,
        0,
        0,
        477,
        480,
        1,
        0,
        0,
        0,
        478,
        480,
        5,
        79,
        0,
        0,
        479,
        468,
        1,
        0,
        0,
        0,
        479,
        478,
        1,
        0,
        0,
        0,
        480,
        59,
        1,
        0,
        0,
        0,
        481,
        482,
        5,
        15,
        0,
        0,
        482,
        484,
        3,
        64,
        32,
        0,
        483,
        485,
        3,
        46,
        23,
        0,
        484,
        483,
        1,
        0,
        0,
        0,
        484,
        485,
        1,
        0,
        0,
        0,
        485,
        61,
        1,
        0,
        0,
        0,
        486,
        492,
        3,
        108,
        54,
        0,
        487,
        492,
        3,
        136,
        68,
        0,
        488,
        492,
        3,
        150,
        75,
        0,
        489,
        492,
        3,
        200,
        100,
        0,
        490,
        492,
        3,
        210,
        105,
        0,
        491,
        486,
        1,
        0,
        0,
        0,
        491,
        487,
        1,
        0,
        0,
        0,
        491,
        488,
        1,
        0,
        0,
        0,
        491,
        489,
        1,
        0,
        0,
        0,
        491,
        490,
        1,
        0,
        0,
        0,
        492,
        63,
        1,
        0,
        0,
        0,
        493,
        494,
        5,
        93,
        0,
        0,
        494,
        65,
        1,
        0,
        0,
        0,
        495,
        496,
        5,
        17,
        0,
        0,
        496,
        498,
        3,
        72,
        36,
        0,
        497,
        499,
        3,
        68,
        34,
        0,
        498,
        497,
        1,
        0,
        0,
        0,
        498,
        499,
        1,
        0,
        0,
        0,
        499,
        512,
        1,
        0,
        0,
        0,
        500,
        501,
        5,
        9,
        0,
        0,
        501,
        502,
        5,
        79,
        0,
        0,
        502,
        505,
        5,
        94,
        0,
        0,
        503,
        506,
        3,
        70,
        35,
        0,
        504,
        506,
        3,
        166,
        83,
        0,
        505,
        503,
        1,
        0,
        0,
        0,
        505,
        504,
        1,
        0,
        0,
        0,
        506,
        507,
        1,
        0,
        0,
        0,
        507,
        505,
        1,
        0,
        0,
        0,
        507,
        508,
        1,
        0,
        0,
        0,
        508,
        509,
        1,
        0,
        0,
        0,
        509,
        510,
        5,
        95,
        0,
        0,
        510,
        513,
        1,
        0,
        0,
        0,
        511,
        513,
        5,
        79,
        0,
        0,
        512,
        500,
        1,
        0,
        0,
        0,
        512,
        511,
        1,
        0,
        0,
        0,
        513,
        67,
        1,
        0,
        0,
        0,
        514,
        515,
        5,
        15,
        0,
        0,
        515,
        517,
        3,
        72,
        36,
        0,
        516,
        518,
        3,
        46,
        23,
        0,
        517,
        516,
        1,
        0,
        0,
        0,
        517,
        518,
        1,
        0,
        0,
        0,
        518,
        69,
        1,
        0,
        0,
        0,
        519,
        526,
        3,
        108,
        54,
        0,
        520,
        526,
        3,
        136,
        68,
        0,
        521,
        526,
        3,
        150,
        75,
        0,
        522,
        526,
        3,
        200,
        100,
        0,
        523,
        526,
        3,
        210,
        105,
        0,
        524,
        526,
        3,
        162,
        81,
        0,
        525,
        519,
        1,
        0,
        0,
        0,
        525,
        520,
        1,
        0,
        0,
        0,
        525,
        521,
        1,
        0,
        0,
        0,
        525,
        522,
        1,
        0,
        0,
        0,
        525,
        523,
        1,
        0,
        0,
        0,
        525,
        524,
        1,
        0,
        0,
        0,
        526,
        71,
        1,
        0,
        0,
        0,
        527,
        528,
        3,
        64,
        32,
        0,
        528,
        529,
        5,
        2,
        0,
        0,
        529,
        531,
        1,
        0,
        0,
        0,
        530,
        527,
        1,
        0,
        0,
        0,
        530,
        531,
        1,
        0,
        0,
        0,
        531,
        532,
        1,
        0,
        0,
        0,
        532,
        533,
        3,
        74,
        37,
        0,
        533,
        73,
        1,
        0,
        0,
        0,
        534,
        535,
        5,
        93,
        0,
        0,
        535,
        75,
        1,
        0,
        0,
        0,
        536,
        537,
        5,
        18,
        0,
        0,
        537,
        539,
        3,
        72,
        36,
        0,
        538,
        540,
        3,
        78,
        39,
        0,
        539,
        538,
        1,
        0,
        0,
        0,
        539,
        540,
        1,
        0,
        0,
        0,
        540,
        553,
        1,
        0,
        0,
        0,
        541,
        542,
        5,
        9,
        0,
        0,
        542,
        543,
        5,
        79,
        0,
        0,
        543,
        546,
        5,
        94,
        0,
        0,
        544,
        547,
        3,
        70,
        35,
        0,
        545,
        547,
        3,
        166,
        83,
        0,
        546,
        544,
        1,
        0,
        0,
        0,
        546,
        545,
        1,
        0,
        0,
        0,
        547,
        548,
        1,
        0,
        0,
        0,
        548,
        546,
        1,
        0,
        0,
        0,
        548,
        549,
        1,
        0,
        0,
        0,
        549,
        550,
        1,
        0,
        0,
        0,
        550,
        551,
        5,
        95,
        0,
        0,
        551,
        554,
        1,
        0,
        0,
        0,
        552,
        554,
        5,
        79,
        0,
        0,
        553,
        541,
        1,
        0,
        0,
        0,
        553,
        552,
        1,
        0,
        0,
        0,
        554,
        77,
        1,
        0,
        0,
        0,
        555,
        556,
        5,
        15,
        0,
        0,
        556,
        558,
        3,
        72,
        36,
        0,
        557,
        559,
        3,
        46,
        23,
        0,
        558,
        557,
        1,
        0,
        0,
        0,
        558,
        559,
        1,
        0,
        0,
        0,
        559,
        79,
        1,
        0,
        0,
        0,
        560,
        564,
        5,
        19,
        0,
        0,
        561,
        562,
        3,
        64,
        32,
        0,
        562,
        563,
        5,
        2,
        0,
        0,
        563,
        565,
        1,
        0,
        0,
        0,
        564,
        561,
        1,
        0,
        0,
        0,
        564,
        565,
        1,
        0,
        0,
        0,
        565,
        566,
        1,
        0,
        0,
        0,
        566,
        569,
        3,
        82,
        41,
        0,
        567,
        568,
        5,
        7,
        0,
        0,
        568,
        570,
        3,
        72,
        36,
        0,
        569,
        567,
        1,
        0,
        0,
        0,
        569,
        570,
        1,
        0,
        0,
        0,
        570,
        582,
        1,
        0,
        0,
        0,
        571,
        572,
        5,
        9,
        0,
        0,
        572,
        573,
        5,
        79,
        0,
        0,
        573,
        575,
        5,
        94,
        0,
        0,
        574,
        576,
        3,
        70,
        35,
        0,
        575,
        574,
        1,
        0,
        0,
        0,
        576,
        577,
        1,
        0,
        0,
        0,
        577,
        575,
        1,
        0,
        0,
        0,
        577,
        578,
        1,
        0,
        0,
        0,
        578,
        579,
        1,
        0,
        0,
        0,
        579,
        580,
        5,
        95,
        0,
        0,
        580,
        583,
        1,
        0,
        0,
        0,
        581,
        583,
        5,
        79,
        0,
        0,
        582,
        571,
        1,
        0,
        0,
        0,
        582,
        581,
        1,
        0,
        0,
        0,
        583,
        81,
        1,
        0,
        0,
        0,
        584,
        585,
        5,
        93,
        0,
        0,
        585,
        83,
        1,
        0,
        0,
        0,
        586,
        589,
        3,
        86,
        43,
        0,
        587,
        589,
        3,
        88,
        44,
        0,
        588,
        586,
        1,
        0,
        0,
        0,
        588,
        587,
        1,
        0,
        0,
        0,
        589,
        85,
        1,
        0,
        0,
        0,
        590,
        591,
        5,
        20,
        0,
        0,
        591,
        592,
        3,
        40,
        20,
        0,
        592,
        593,
        5,
        9,
        0,
        0,
        593,
        594,
        5,
        80,
        0,
        0,
        594,
        599,
        3,
        36,
        18,
        0,
        595,
        596,
        5,
        8,
        0,
        0,
        596,
        598,
        3,
        36,
        18,
        0,
        597,
        595,
        1,
        0,
        0,
        0,
        598,
        601,
        1,
        0,
        0,
        0,
        599,
        597,
        1,
        0,
        0,
        0,
        599,
        600,
        1,
        0,
        0,
        0,
        600,
        602,
        1,
        0,
        0,
        0,
        601,
        599,
        1,
        0,
        0,
        0,
        602,
        603,
        5,
        81,
        0,
        0,
        603,
        604,
        5,
        79,
        0,
        0,
        604,
        87,
        1,
        0,
        0,
        0,
        605,
        606,
        5,
        20,
        0,
        0,
        606,
        607,
        3,
        90,
        45,
        0,
        607,
        608,
        5,
        9,
        0,
        0,
        608,
        609,
        5,
        79,
        0,
        0,
        609,
        611,
        5,
        94,
        0,
        0,
        610,
        612,
        3,
        92,
        46,
        0,
        611,
        610,
        1,
        0,
        0,
        0,
        612,
        613,
        1,
        0,
        0,
        0,
        613,
        611,
        1,
        0,
        0,
        0,
        613,
        614,
        1,
        0,
        0,
        0,
        614,
        615,
        1,
        0,
        0,
        0,
        615,
        616,
        5,
        95,
        0,
        0,
        616,
        89,
        1,
        0,
        0,
        0,
        617,
        620,
        3,
        106,
        53,
        0,
        618,
        620,
        3,
        72,
        36,
        0,
        619,
        617,
        1,
        0,
        0,
        0,
        619,
        618,
        1,
        0,
        0,
        0,
        620,
        91,
        1,
        0,
        0,
        0,
        621,
        626,
        3,
        52,
        26,
        0,
        622,
        626,
        3,
        62,
        31,
        0,
        623,
        626,
        3,
        70,
        35,
        0,
        624,
        626,
        3,
        166,
        83,
        0,
        625,
        621,
        1,
        0,
        0,
        0,
        625,
        622,
        1,
        0,
        0,
        0,
        625,
        623,
        1,
        0,
        0,
        0,
        625,
        624,
        1,
        0,
        0,
        0,
        626,
        93,
        1,
        0,
        0,
        0,
        627,
        628,
        5,
        21,
        0,
        0,
        628,
        633,
        3,
        54,
        27,
        0,
        629,
        630,
        5,
        8,
        0,
        0,
        630,
        632,
        3,
        54,
        27,
        0,
        631,
        629,
        1,
        0,
        0,
        0,
        632,
        635,
        1,
        0,
        0,
        0,
        633,
        631,
        1,
        0,
        0,
        0,
        633,
        634,
        1,
        0,
        0,
        0,
        634,
        636,
        1,
        0,
        0,
        0,
        635,
        633,
        1,
        0,
        0,
        0,
        636,
        637,
        5,
        9,
        0,
        0,
        637,
        640,
        3,
        96,
        48,
        0,
        638,
        639,
        5,
        11,
        0,
        0,
        639,
        641,
        3,
        144,
        72,
        0,
        640,
        638,
        1,
        0,
        0,
        0,
        640,
        641,
        1,
        0,
        0,
        0,
        641,
        644,
        1,
        0,
        0,
        0,
        642,
        645,
        3,
        146,
        73,
        0,
        643,
        645,
        5,
        79,
        0,
        0,
        644,
        642,
        1,
        0,
        0,
        0,
        644,
        643,
        1,
        0,
        0,
        0,
        645,
        95,
        1,
        0,
        0,
        0,
        646,
        649,
        3,
        98,
        49,
        0,
        647,
        649,
        3,
        100,
        50,
        0,
        648,
        646,
        1,
        0,
        0,
        0,
        648,
        647,
        1,
        0,
        0,
        0,
        649,
        97,
        1,
        0,
        0,
        0,
        650,
        654,
        3,
        104,
        52,
        0,
        651,
        654,
        3,
        106,
        53,
        0,
        652,
        654,
        3,
        72,
        36,
        0,
        653,
        650,
        1,
        0,
        0,
        0,
        653,
        651,
        1,
        0,
        0,
        0,
        653,
        652,
        1,
        0,
        0,
        0,
        654,
        99,
        1,
        0,
        0,
        0,
        655,
        656,
        3,
        102,
        51,
        0,
        656,
        101,
        1,
        0,
        0,
        0,
        657,
        658,
        5,
        22,
        0,
        0,
        658,
        659,
        5,
        7,
        0,
        0,
        659,
        660,
        3,
        98,
        49,
        0,
        660,
        103,
        1,
        0,
        0,
        0,
        661,
        662,
        7,
        1,
        0,
        0,
        662,
        105,
        1,
        0,
        0,
        0,
        663,
        664,
        5,
        93,
        0,
        0,
        664,
        107,
        1,
        0,
        0,
        0,
        665,
        666,
        5,
        28,
        0,
        0,
        666,
        671,
        3,
        118,
        59,
        0,
        667,
        668,
        5,
        82,
        0,
        0,
        668,
        669,
        3,
        260,
        130,
        0,
        669,
        670,
        5,
        83,
        0,
        0,
        670,
        672,
        1,
        0,
        0,
        0,
        671,
        667,
        1,
        0,
        0,
        0,
        671,
        672,
        1,
        0,
        0,
        0,
        672,
        675,
        1,
        0,
        0,
        0,
        673,
        674,
        5,
        4,
        0,
        0,
        674,
        676,
        3,
        110,
        55,
        0,
        675,
        673,
        1,
        0,
        0,
        0,
        675,
        676,
        1,
        0,
        0,
        0,
        676,
        677,
        1,
        0,
        0,
        0,
        677,
        678,
        5,
        79,
        0,
        0,
        678,
        109,
        1,
        0,
        0,
        0,
        679,
        685,
        3,
        112,
        56,
        0,
        680,
        682,
        3,
        114,
        57,
        0,
        681,
        680,
        1,
        0,
        0,
        0,
        681,
        682,
        1,
        0,
        0,
        0,
        682,
        683,
        1,
        0,
        0,
        0,
        683,
        684,
        5,
        29,
        0,
        0,
        684,
        686,
        3,
        122,
        61,
        0,
        685,
        681,
        1,
        0,
        0,
        0,
        685,
        686,
        1,
        0,
        0,
        0,
        686,
        689,
        1,
        0,
        0,
        0,
        687,
        689,
        3,
        122,
        61,
        0,
        688,
        679,
        1,
        0,
        0,
        0,
        688,
        687,
        1,
        0,
        0,
        0,
        689,
        111,
        1,
        0,
        0,
        0,
        690,
        691,
        5,
        30,
        0,
        0,
        691,
        692,
        3,
        120,
        60,
        0,
        692,
        113,
        1,
        0,
        0,
        0,
        693,
        694,
        5,
        31,
        0,
        0,
        694,
        695,
        3,
        116,
        58,
        0,
        695,
        115,
        1,
        0,
        0,
        0,
        696,
        697,
        5,
        93,
        0,
        0,
        697,
        117,
        1,
        0,
        0,
        0,
        698,
        699,
        5,
        93,
        0,
        0,
        699,
        119,
        1,
        0,
        0,
        0,
        700,
        701,
        3,
        220,
        110,
        0,
        701,
        702,
        5,
        2,
        0,
        0,
        702,
        704,
        1,
        0,
        0,
        0,
        703,
        700,
        1,
        0,
        0,
        0,
        703,
        704,
        1,
        0,
        0,
        0,
        704,
        705,
        1,
        0,
        0,
        0,
        705,
        706,
        3,
        118,
        59,
        0,
        706,
        121,
        1,
        0,
        0,
        0,
        707,
        713,
        3,
        132,
        66,
        0,
        708,
        713,
        3,
        124,
        62,
        0,
        709,
        713,
        3,
        126,
        63,
        0,
        710,
        713,
        3,
        128,
        64,
        0,
        711,
        713,
        3,
        130,
        65,
        0,
        712,
        707,
        1,
        0,
        0,
        0,
        712,
        708,
        1,
        0,
        0,
        0,
        712,
        709,
        1,
        0,
        0,
        0,
        712,
        710,
        1,
        0,
        0,
        0,
        712,
        711,
        1,
        0,
        0,
        0,
        713,
        123,
        1,
        0,
        0,
        0,
        714,
        715,
        5,
        32,
        0,
        0,
        715,
        716,
        5,
        82,
        0,
        0,
        716,
        717,
        3,
        132,
        66,
        0,
        717,
        718,
        5,
        83,
        0,
        0,
        718,
        125,
        1,
        0,
        0,
        0,
        719,
        720,
        5,
        33,
        0,
        0,
        720,
        721,
        5,
        82,
        0,
        0,
        721,
        722,
        3,
        132,
        66,
        0,
        722,
        723,
        5,
        83,
        0,
        0,
        723,
        127,
        1,
        0,
        0,
        0,
        724,
        725,
        5,
        34,
        0,
        0,
        725,
        726,
        5,
        82,
        0,
        0,
        726,
        727,
        3,
        134,
        67,
        0,
        727,
        728,
        5,
        83,
        0,
        0,
        728,
        129,
        1,
        0,
        0,
        0,
        729,
        730,
        5,
        35,
        0,
        0,
        730,
        731,
        5,
        82,
        0,
        0,
        731,
        737,
        3,
        134,
        67,
        0,
        732,
        733,
        5,
        8,
        0,
        0,
        733,
        734,
        5,
        93,
        0,
        0,
        734,
        735,
        6,
        65,
        -1,
        0,
        735,
        736,
        5,
        9,
        0,
        0,
        736,
        738,
        3,
        134,
        67,
        0,
        737,
        732,
        1,
        0,
        0,
        0,
        737,
        738,
        1,
        0,
        0,
        0,
        738,
        739,
        1,
        0,
        0,
        0,
        739,
        740,
        5,
        83,
        0,
        0,
        740,
        131,
        1,
        0,
        0,
        0,
        741,
        742,
        3,
        220,
        110,
        0,
        742,
        133,
        1,
        0,
        0,
        0,
        743,
        744,
        3,
        220,
        110,
        0,
        744,
        135,
        1,
        0,
        0,
        0,
        745,
        748,
        3,
        138,
        69,
        0,
        746,
        748,
        3,
        140,
        70,
        0,
        747,
        745,
        1,
        0,
        0,
        0,
        747,
        746,
        1,
        0,
        0,
        0,
        748,
        137,
        1,
        0,
        0,
        0,
        749,
        754,
        3,
        54,
        27,
        0,
        750,
        751,
        5,
        8,
        0,
        0,
        751,
        753,
        3,
        54,
        27,
        0,
        752,
        750,
        1,
        0,
        0,
        0,
        753,
        756,
        1,
        0,
        0,
        0,
        754,
        752,
        1,
        0,
        0,
        0,
        754,
        755,
        1,
        0,
        0,
        0,
        755,
        757,
        1,
        0,
        0,
        0,
        756,
        754,
        1,
        0,
        0,
        0,
        757,
        758,
        5,
        9,
        0,
        0,
        758,
        761,
        3,
        96,
        48,
        0,
        759,
        760,
        5,
        11,
        0,
        0,
        760,
        762,
        3,
        144,
        72,
        0,
        761,
        759,
        1,
        0,
        0,
        0,
        761,
        762,
        1,
        0,
        0,
        0,
        762,
        765,
        1,
        0,
        0,
        0,
        763,
        766,
        3,
        146,
        73,
        0,
        764,
        766,
        5,
        79,
        0,
        0,
        765,
        763,
        1,
        0,
        0,
        0,
        765,
        764,
        1,
        0,
        0,
        0,
        766,
        139,
        1,
        0,
        0,
        0,
        767,
        768,
        5,
        36,
        0,
        0,
        768,
        773,
        3,
        54,
        27,
        0,
        769,
        770,
        5,
        8,
        0,
        0,
        770,
        772,
        3,
        54,
        27,
        0,
        771,
        769,
        1,
        0,
        0,
        0,
        772,
        775,
        1,
        0,
        0,
        0,
        773,
        771,
        1,
        0,
        0,
        0,
        773,
        774,
        1,
        0,
        0,
        0,
        774,
        776,
        1,
        0,
        0,
        0,
        775,
        773,
        1,
        0,
        0,
        0,
        776,
        777,
        5,
        9,
        0,
        0,
        777,
        783,
        3,
        96,
        48,
        0,
        778,
        781,
        5,
        11,
        0,
        0,
        779,
        782,
        3,
        142,
        71,
        0,
        780,
        782,
        3,
        252,
        126,
        0,
        781,
        779,
        1,
        0,
        0,
        0,
        781,
        780,
        1,
        0,
        0,
        0,
        782,
        784,
        1,
        0,
        0,
        0,
        783,
        778,
        1,
        0,
        0,
        0,
        783,
        784,
        1,
        0,
        0,
        0,
        784,
        785,
        1,
        0,
        0,
        0,
        785,
        786,
        5,
        79,
        0,
        0,
        786,
        141,
        1,
        0,
        0,
        0,
        787,
        788,
        5,
        37,
        0,
        0,
        788,
        789,
        5,
        82,
        0,
        0,
        789,
        790,
        3,
        220,
        110,
        0,
        790,
        791,
        5,
        8,
        0,
        0,
        791,
        794,
        3,
        110,
        55,
        0,
        792,
        793,
        5,
        8,
        0,
        0,
        793,
        795,
        3,
        144,
        72,
        0,
        794,
        792,
        1,
        0,
        0,
        0,
        794,
        795,
        1,
        0,
        0,
        0,
        795,
        796,
        1,
        0,
        0,
        0,
        796,
        797,
        5,
        83,
        0,
        0,
        797,
        143,
        1,
        0,
        0,
        0,
        798,
        799,
        3,
        220,
        110,
        0,
        799,
        145,
        1,
        0,
        0,
        0,
        800,
        801,
        5,
        38,
        0,
        0,
        801,
        802,
        5,
        9,
        0,
        0,
        802,
        803,
        5,
        79,
        0,
        0,
        803,
        805,
        5,
        94,
        0,
        0,
        804,
        806,
        3,
        148,
        74,
        0,
        805,
        804,
        1,
        0,
        0,
        0,
        806,
        807,
        1,
        0,
        0,
        0,
        807,
        805,
        1,
        0,
        0,
        0,
        807,
        808,
        1,
        0,
        0,
        0,
        808,
        809,
        1,
        0,
        0,
        0,
        809,
        810,
        5,
        95,
        0,
        0,
        810,
        147,
        1,
        0,
        0,
        0,
        811,
        814,
        3,
        150,
        75,
        0,
        812,
        814,
        3,
        210,
        105,
        0,
        813,
        811,
        1,
        0,
        0,
        0,
        813,
        812,
        1,
        0,
        0,
        0,
        814,
        149,
        1,
        0,
        0,
        0,
        815,
        818,
        3,
        152,
        76,
        0,
        816,
        818,
        3,
        158,
        79,
        0,
        817,
        815,
        1,
        0,
        0,
        0,
        817,
        816,
        1,
        0,
        0,
        0,
        818,
        151,
        1,
        0,
        0,
        0,
        819,
        820,
        5,
        39,
        0,
        0,
        820,
        822,
        5,
        82,
        0,
        0,
        821,
        823,
        3,
        154,
        77,
        0,
        822,
        821,
        1,
        0,
        0,
        0,
        822,
        823,
        1,
        0,
        0,
        0,
        823,
        824,
        1,
        0,
        0,
        0,
        824,
        825,
        3,
        156,
        78,
        0,
        825,
        826,
        5,
        83,
        0,
        0,
        826,
        827,
        5,
        79,
        0,
        0,
        827,
        153,
        1,
        0,
        0,
        0,
        828,
        829,
        7,
        2,
        0,
        0,
        829,
        155,
        1,
        0,
        0,
        0,
        830,
        831,
        3,
        220,
        110,
        0,
        831,
        157,
        1,
        0,
        0,
        0,
        832,
        833,
        5,
        42,
        0,
        0,
        833,
        834,
        5,
        82,
        0,
        0,
        834,
        835,
        3,
        160,
        80,
        0,
        835,
        836,
        5,
        83,
        0,
        0,
        836,
        837,
        5,
        79,
        0,
        0,
        837,
        159,
        1,
        0,
        0,
        0,
        838,
        841,
        3,
        54,
        27,
        0,
        839,
        841,
        3,
        248,
        124,
        0,
        840,
        838,
        1,
        0,
        0,
        0,
        840,
        839,
        1,
        0,
        0,
        0,
        841,
        161,
        1,
        0,
        0,
        0,
        842,
        845,
        3,
        164,
        82,
        0,
        843,
        845,
        3,
        188,
        94,
        0,
        844,
        842,
        1,
        0,
        0,
        0,
        844,
        843,
        1,
        0,
        0,
        0,
        845,
        846,
        1,
        0,
        0,
        0,
        846,
        847,
        5,
        2,
        0,
        0,
        847,
        849,
        1,
        0,
        0,
        0,
        848,
        844,
        1,
        0,
        0,
        0,
        848,
        849,
        1,
        0,
        0,
        0,
        849,
        850,
        1,
        0,
        0,
        0,
        850,
        851,
        3,
        82,
        41,
        0,
        851,
        853,
        5,
        82,
        0,
        0,
        852,
        854,
        3,
        266,
        133,
        0,
        853,
        852,
        1,
        0,
        0,
        0,
        853,
        854,
        1,
        0,
        0,
        0,
        854,
        855,
        1,
        0,
        0,
        0,
        855,
        856,
        5,
        83,
        0,
        0,
        856,
        857,
        5,
        79,
        0,
        0,
        857,
        163,
        1,
        0,
        0,
        0,
        858,
        859,
        3,
        188,
        94,
        0,
        859,
        860,
        5,
        2,
        0,
        0,
        860,
        861,
        1,
        0,
        0,
        0,
        861,
        862,
        3,
        74,
        37,
        0,
        862,
        165,
        1,
        0,
        0,
        0,
        863,
        866,
        3,
        168,
        84,
        0,
        864,
        866,
        3,
        172,
        86,
        0,
        865,
        863,
        1,
        0,
        0,
        0,
        865,
        864,
        1,
        0,
        0,
        0,
        866,
        167,
        1,
        0,
        0,
        0,
        867,
        868,
        5,
        43,
        0,
        0,
        868,
        869,
        3,
        110,
        55,
        0,
        869,
        870,
        5,
        9,
        0,
        0,
        870,
        871,
        5,
        79,
        0,
        0,
        871,
        873,
        5,
        94,
        0,
        0,
        872,
        874,
        3,
        170,
        85,
        0,
        873,
        872,
        1,
        0,
        0,
        0,
        874,
        875,
        1,
        0,
        0,
        0,
        875,
        873,
        1,
        0,
        0,
        0,
        875,
        876,
        1,
        0,
        0,
        0,
        876,
        877,
        1,
        0,
        0,
        0,
        877,
        878,
        5,
        95,
        0,
        0,
        878,
        169,
        1,
        0,
        0,
        0,
        879,
        882,
        3,
        194,
        97,
        0,
        880,
        882,
        3,
        192,
        96,
        0,
        881,
        879,
        1,
        0,
        0,
        0,
        881,
        880,
        1,
        0,
        0,
        0,
        882,
        171,
        1,
        0,
        0,
        0,
        883,
        884,
        5,
        44,
        0,
        0,
        884,
        885,
        3,
        174,
        87,
        0,
        885,
        173,
        1,
        0,
        0,
        0,
        886,
        887,
        3,
        186,
        93,
        0,
        887,
        888,
        5,
        9,
        0,
        0,
        888,
        890,
        1,
        0,
        0,
        0,
        889,
        886,
        1,
        0,
        0,
        0,
        889,
        890,
        1,
        0,
        0,
        0,
        890,
        896,
        1,
        0,
        0,
        0,
        891,
        897,
        3,
        176,
        88,
        0,
        892,
        897,
        3,
        180,
        90,
        0,
        893,
        897,
        3,
        190,
        95,
        0,
        894,
        897,
        3,
        192,
        96,
        0,
        895,
        897,
        3,
        194,
        97,
        0,
        896,
        891,
        1,
        0,
        0,
        0,
        896,
        892,
        1,
        0,
        0,
        0,
        896,
        893,
        1,
        0,
        0,
        0,
        896,
        894,
        1,
        0,
        0,
        0,
        896,
        895,
        1,
        0,
        0,
        0,
        897,
        175,
        1,
        0,
        0,
        0,
        898,
        904,
        3,
        178,
        89,
        0,
        899,
        901,
        5,
        82,
        0,
        0,
        900,
        902,
        3,
        266,
        133,
        0,
        901,
        900,
        1,
        0,
        0,
        0,
        901,
        902,
        1,
        0,
        0,
        0,
        902,
        903,
        1,
        0,
        0,
        0,
        903,
        905,
        5,
        83,
        0,
        0,
        904,
        899,
        1,
        0,
        0,
        0,
        904,
        905,
        1,
        0,
        0,
        0,
        905,
        906,
        1,
        0,
        0,
        0,
        906,
        907,
        5,
        9,
        0,
        0,
        907,
        908,
        5,
        79,
        0,
        0,
        908,
        910,
        5,
        94,
        0,
        0,
        909,
        911,
        3,
        174,
        87,
        0,
        910,
        909,
        1,
        0,
        0,
        0,
        911,
        912,
        1,
        0,
        0,
        0,
        912,
        910,
        1,
        0,
        0,
        0,
        912,
        913,
        1,
        0,
        0,
        0,
        913,
        914,
        1,
        0,
        0,
        0,
        914,
        916,
        5,
        95,
        0,
        0,
        915,
        917,
        3,
        182,
        91,
        0,
        916,
        915,
        1,
        0,
        0,
        0,
        916,
        917,
        1,
        0,
        0,
        0,
        917,
        177,
        1,
        0,
        0,
        0,
        918,
        919,
        7,
        3,
        0,
        0,
        919,
        179,
        1,
        0,
        0,
        0,
        920,
        921,
        3,
        188,
        94,
        0,
        921,
        922,
        5,
        2,
        0,
        0,
        922,
        924,
        1,
        0,
        0,
        0,
        923,
        920,
        1,
        0,
        0,
        0,
        923,
        924,
        1,
        0,
        0,
        0,
        924,
        925,
        1,
        0,
        0,
        0,
        925,
        926,
        3,
        74,
        37,
        0,
        926,
        928,
        5,
        82,
        0,
        0,
        927,
        929,
        3,
        266,
        133,
        0,
        928,
        927,
        1,
        0,
        0,
        0,
        928,
        929,
        1,
        0,
        0,
        0,
        929,
        930,
        1,
        0,
        0,
        0,
        930,
        933,
        5,
        83,
        0,
        0,
        931,
        934,
        3,
        182,
        91,
        0,
        932,
        934,
        5,
        79,
        0,
        0,
        933,
        931,
        1,
        0,
        0,
        0,
        933,
        932,
        1,
        0,
        0,
        0,
        934,
        181,
        1,
        0,
        0,
        0,
        935,
        936,
        5,
        38,
        0,
        0,
        936,
        937,
        5,
        9,
        0,
        0,
        937,
        938,
        5,
        79,
        0,
        0,
        938,
        940,
        5,
        94,
        0,
        0,
        939,
        941,
        3,
        184,
        92,
        0,
        940,
        939,
        1,
        0,
        0,
        0,
        941,
        942,
        1,
        0,
        0,
        0,
        942,
        940,
        1,
        0,
        0,
        0,
        942,
        943,
        1,
        0,
        0,
        0,
        943,
        944,
        1,
        0,
        0,
        0,
        944,
        945,
        5,
        95,
        0,
        0,
        945,
        183,
        1,
        0,
        0,
        0,
        946,
        950,
        3,
        150,
        75,
        0,
        947,
        950,
        3,
        162,
        81,
        0,
        948,
        950,
        3,
        196,
        98,
        0,
        949,
        946,
        1,
        0,
        0,
        0,
        949,
        947,
        1,
        0,
        0,
        0,
        949,
        948,
        1,
        0,
        0,
        0,
        950,
        185,
        1,
        0,
        0,
        0,
        951,
        952,
        5,
        93,
        0,
        0,
        952,
        187,
        1,
        0,
        0,
        0,
        953,
        954,
        3,
        64,
        32,
        0,
        954,
        189,
        1,
        0,
        0,
        0,
        955,
        956,
        5,
        48,
        0,
        0,
        956,
        957,
        3,
        110,
        55,
        0,
        957,
        958,
        5,
        79,
        0,
        0,
        958,
        191,
        1,
        0,
        0,
        0,
        959,
        960,
        5,
        49,
        0,
        0,
        960,
        965,
        3,
        118,
        59,
        0,
        961,
        962,
        5,
        82,
        0,
        0,
        962,
        963,
        3,
        266,
        133,
        0,
        963,
        964,
        5,
        83,
        0,
        0,
        964,
        966,
        1,
        0,
        0,
        0,
        965,
        961,
        1,
        0,
        0,
        0,
        965,
        966,
        1,
        0,
        0,
        0,
        966,
        967,
        1,
        0,
        0,
        0,
        967,
        968,
        5,
        79,
        0,
        0,
        968,
        193,
        1,
        0,
        0,
        0,
        969,
        970,
        5,
        50,
        0,
        0,
        970,
        971,
        3,
        198,
        99,
        0,
        971,
        972,
        5,
        79,
        0,
        0,
        972,
        195,
        1,
        0,
        0,
        0,
        973,
        974,
        5,
        51,
        0,
        0,
        974,
        975,
        3,
        110,
        55,
        0,
        975,
        976,
        5,
        79,
        0,
        0,
        976,
        197,
        1,
        0,
        0,
        0,
        977,
        978,
        3,
        246,
        123,
        0,
        978,
        980,
        5,
        82,
        0,
        0,
        979,
        981,
        3,
        266,
        133,
        0,
        980,
        979,
        1,
        0,
        0,
        0,
        980,
        981,
        1,
        0,
        0,
        0,
        981,
        982,
        1,
        0,
        0,
        0,
        982,
        983,
        5,
        83,
        0,
        0,
        983,
        199,
        1,
        0,
        0,
        0,
        984,
        985,
        5,
        52,
        0,
        0,
        985,
        986,
        3,
        208,
        104,
        0,
        986,
        988,
        5,
        82,
        0,
        0,
        987,
        989,
        3,
        260,
        130,
        0,
        988,
        987,
        1,
        0,
        0,
        0,
        988,
        989,
        1,
        0,
        0,
        0,
        989,
        990,
        1,
        0,
        0,
        0,
        990,
        993,
        5,
        83,
        0,
        0,
        991,
        992,
        5,
        53,
        0,
        0,
        992,
        994,
        3,
        202,
        101,
        0,
        993,
        991,
        1,
        0,
        0,
        0,
        993,
        994,
        1,
        0,
        0,
        0,
        994,
        995,
        1,
        0,
        0,
        0,
        995,
        996,
        3,
        204,
        102,
        0,
        996,
        997,
        5,
        79,
        0,
        0,
        997,
        201,
        1,
        0,
        0,
        0,
        998,
        999,
        3,
        96,
        48,
        0,
        999,
        203,
        1,
        0,
        0,
        0,
        1000,
        1002,
        5,
        4,
        0,
        0,
        1001,
        1003,
        3,
        206,
        103,
        0,
        1002,
        1001,
        1,
        0,
        0,
        0,
        1002,
        1003,
        1,
        0,
        0,
        0,
        1003,
        1015,
        1,
        0,
        0,
        0,
        1004,
        1005,
        5,
        54,
        0,
        0,
        1005,
        1016,
        3,
        220,
        110,
        0,
        1006,
        1016,
        5,
        55,
        0,
        0,
        1007,
        1008,
        5,
        56,
        0,
        0,
        1008,
        1009,
        3,
        8,
        4,
        0,
        1009,
        1011,
        5,
        82,
        0,
        0,
        1010,
        1012,
        3,
        266,
        133,
        0,
        1011,
        1010,
        1,
        0,
        0,
        0,
        1011,
        1012,
        1,
        0,
        0,
        0,
        1012,
        1013,
        1,
        0,
        0,
        0,
        1013,
        1014,
        5,
        83,
        0,
        0,
        1014,
        1016,
        1,
        0,
        0,
        0,
        1015,
        1004,
        1,
        0,
        0,
        0,
        1015,
        1006,
        1,
        0,
        0,
        0,
        1015,
        1007,
        1,
        0,
        0,
        0,
        1016,
        205,
        1,
        0,
        0,
        0,
        1017,
        1018,
        5,
        57,
        0,
        0,
        1018,
        207,
        1,
        0,
        0,
        0,
        1019,
        1020,
        5,
        93,
        0,
        0,
        1020,
        209,
        1,
        0,
        0,
        0,
        1021,
        1024,
        3,
        212,
        106,
        0,
        1022,
        1024,
        3,
        214,
        107,
        0,
        1023,
        1021,
        1,
        0,
        0,
        0,
        1023,
        1022,
        1,
        0,
        0,
        0,
        1024,
        211,
        1,
        0,
        0,
        0,
        1025,
        1026,
        5,
        58,
        0,
        0,
        1026,
        1028,
        5,
        82,
        0,
        0,
        1027,
        1029,
        3,
        218,
        109,
        0,
        1028,
        1027,
        1,
        0,
        0,
        0,
        1028,
        1029,
        1,
        0,
        0,
        0,
        1029,
        1033,
        1,
        0,
        0,
        0,
        1030,
        1032,
        3,
        216,
        108,
        0,
        1031,
        1030,
        1,
        0,
        0,
        0,
        1032,
        1035,
        1,
        0,
        0,
        0,
        1033,
        1031,
        1,
        0,
        0,
        0,
        1033,
        1034,
        1,
        0,
        0,
        0,
        1034,
        1036,
        1,
        0,
        0,
        0,
        1035,
        1033,
        1,
        0,
        0,
        0,
        1036,
        1037,
        5,
        83,
        0,
        0,
        1037,
        1038,
        5,
        79,
        0,
        0,
        1038,
        213,
        1,
        0,
        0,
        0,
        1039,
        1040,
        5,
        59,
        0,
        0,
        1040,
        1042,
        5,
        82,
        0,
        0,
        1041,
        1043,
        3,
        218,
        109,
        0,
        1042,
        1041,
        1,
        0,
        0,
        0,
        1042,
        1043,
        1,
        0,
        0,
        0,
        1043,
        1047,
        1,
        0,
        0,
        0,
        1044,
        1046,
        3,
        216,
        108,
        0,
        1045,
        1044,
        1,
        0,
        0,
        0,
        1046,
        1049,
        1,
        0,
        0,
        0,
        1047,
        1045,
        1,
        0,
        0,
        0,
        1047,
        1048,
        1,
        0,
        0,
        0,
        1048,
        1050,
        1,
        0,
        0,
        0,
        1049,
        1047,
        1,
        0,
        0,
        0,
        1050,
        1051,
        5,
        83,
        0,
        0,
        1051,
        1052,
        5,
        79,
        0,
        0,
        1052,
        215,
        1,
        0,
        0,
        0,
        1053,
        1054,
        5,
        8,
        0,
        0,
        1054,
        1055,
        5,
        54,
        0,
        0,
        1055,
        1056,
        5,
        9,
        0,
        0,
        1056,
        1076,
        3,
        220,
        110,
        0,
        1057,
        1058,
        5,
        8,
        0,
        0,
        1058,
        1059,
        5,
        6,
        0,
        0,
        1059,
        1060,
        5,
        9,
        0,
        0,
        1060,
        1076,
        5,
        93,
        0,
        0,
        1061,
        1062,
        5,
        8,
        0,
        0,
        1062,
        1063,
        5,
        60,
        0,
        0,
        1063,
        1064,
        5,
        9,
        0,
        0,
        1064,
        1076,
        3,
        256,
        128,
        0,
        1065,
        1066,
        5,
        8,
        0,
        0,
        1066,
        1067,
        5,
        35,
        0,
        0,
        1067,
        1068,
        5,
        9,
        0,
        0,
        1068,
        1076,
        3,
        252,
        126,
        0,
        1069,
        1070,
        5,
        8,
        0,
        0,
        1070,
        1071,
        5,
        28,
        0,
        0,
        1071,
        1072,
        5,
        9,
        0,
        0,
        1072,
        1076,
        3,
        118,
        59,
        0,
        1073,
        1074,
        5,
        8,
        0,
        0,
        1074,
        1076,
        3,
        270,
        135,
        0,
        1075,
        1053,
        1,
        0,
        0,
        0,
        1075,
        1057,
        1,
        0,
        0,
        0,
        1075,
        1061,
        1,
        0,
        0,
        0,
        1075,
        1065,
        1,
        0,
        0,
        0,
        1075,
        1069,
        1,
        0,
        0,
        0,
        1075,
        1073,
        1,
        0,
        0,
        0,
        1076,
        217,
        1,
        0,
        0,
        0,
        1077,
        1078,
        5,
        93,
        0,
        0,
        1078,
        219,
        1,
        0,
        0,
        0,
        1079,
        1082,
        3,
        224,
        112,
        0,
        1080,
        1082,
        3,
        222,
        111,
        0,
        1081,
        1079,
        1,
        0,
        0,
        0,
        1081,
        1080,
        1,
        0,
        0,
        0,
        1082,
        221,
        1,
        0,
        0,
        0,
        1083,
        1084,
        3,
        224,
        112,
        0,
        1084,
        1085,
        5,
        61,
        0,
        0,
        1085,
        1086,
        3,
        220,
        110,
        0,
        1086,
        1087,
        5,
        9,
        0,
        0,
        1087,
        1088,
        3,
        220,
        110,
        0,
        1088,
        223,
        1,
        0,
        0,
        0,
        1089,
        1094,
        3,
        226,
        113,
        0,
        1090,
        1091,
        5,
        62,
        0,
        0,
        1091,
        1093,
        3,
        226,
        113,
        0,
        1092,
        1090,
        1,
        0,
        0,
        0,
        1093,
        1096,
        1,
        0,
        0,
        0,
        1094,
        1092,
        1,
        0,
        0,
        0,
        1094,
        1095,
        1,
        0,
        0,
        0,
        1095,
        225,
        1,
        0,
        0,
        0,
        1096,
        1094,
        1,
        0,
        0,
        0,
        1097,
        1102,
        3,
        228,
        114,
        0,
        1098,
        1099,
        5,
        63,
        0,
        0,
        1099,
        1101,
        3,
        228,
        114,
        0,
        1100,
        1098,
        1,
        0,
        0,
        0,
        1101,
        1104,
        1,
        0,
        0,
        0,
        1102,
        1100,
        1,
        0,
        0,
        0,
        1102,
        1103,
        1,
        0,
        0,
        0,
        1103,
        227,
        1,
        0,
        0,
        0,
        1104,
        1102,
        1,
        0,
        0,
        0,
        1105,
        1110,
        3,
        230,
        115,
        0,
        1106,
        1107,
        5,
        64,
        0,
        0,
        1107,
        1109,
        3,
        230,
        115,
        0,
        1108,
        1106,
        1,
        0,
        0,
        0,
        1109,
        1112,
        1,
        0,
        0,
        0,
        1110,
        1108,
        1,
        0,
        0,
        0,
        1110,
        1111,
        1,
        0,
        0,
        0,
        1111,
        229,
        1,
        0,
        0,
        0,
        1112,
        1110,
        1,
        0,
        0,
        0,
        1113,
        1114,
        5,
        65,
        0,
        0,
        1114,
        1117,
        3,
        230,
        115,
        0,
        1115,
        1117,
        3,
        232,
        116,
        0,
        1116,
        1113,
        1,
        0,
        0,
        0,
        1116,
        1115,
        1,
        0,
        0,
        0,
        1117,
        231,
        1,
        0,
        0,
        0,
        1118,
        1119,
        6,
        116,
        -1,
        0,
        1119,
        1120,
        3,
        236,
        118,
        0,
        1120,
        1127,
        1,
        0,
        0,
        0,
        1121,
        1122,
        10,
        1,
        0,
        0,
        1122,
        1123,
        3,
        234,
        117,
        0,
        1123,
        1124,
        3,
        236,
        118,
        0,
        1124,
        1126,
        1,
        0,
        0,
        0,
        1125,
        1121,
        1,
        0,
        0,
        0,
        1126,
        1129,
        1,
        0,
        0,
        0,
        1127,
        1125,
        1,
        0,
        0,
        0,
        1127,
        1128,
        1,
        0,
        0,
        0,
        1128,
        233,
        1,
        0,
        0,
        0,
        1129,
        1127,
        1,
        0,
        0,
        0,
        1130,
        1131,
        7,
        4,
        0,
        0,
        1131,
        235,
        1,
        0,
        0,
        0,
        1132,
        1133,
        6,
        118,
        -1,
        0,
        1133,
        1134,
        3,
        240,
        120,
        0,
        1134,
        1141,
        1,
        0,
        0,
        0,
        1135,
        1136,
        10,
        1,
        0,
        0,
        1136,
        1137,
        3,
        238,
        119,
        0,
        1137,
        1138,
        3,
        240,
        120,
        0,
        1138,
        1140,
        1,
        0,
        0,
        0,
        1139,
        1135,
        1,
        0,
        0,
        0,
        1140,
        1143,
        1,
        0,
        0,
        0,
        1141,
        1139,
        1,
        0,
        0,
        0,
        1141,
        1142,
        1,
        0,
        0,
        0,
        1142,
        237,
        1,
        0,
        0,
        0,
        1143,
        1141,
        1,
        0,
        0,
        0,
        1144,
        1145,
        7,
        5,
        0,
        0,
        1145,
        239,
        1,
        0,
        0,
        0,
        1146,
        1147,
        6,
        120,
        -1,
        0,
        1147,
        1148,
        3,
        244,
        122,
        0,
        1148,
        1155,
        1,
        0,
        0,
        0,
        1149,
        1150,
        10,
        1,
        0,
        0,
        1150,
        1151,
        3,
        242,
        121,
        0,
        1151,
        1152,
        3,
        244,
        122,
        0,
        1152,
        1154,
        1,
        0,
        0,
        0,
        1153,
        1149,
        1,
        0,
        0,
        0,
        1154,
        1157,
        1,
        0,
        0,
        0,
        1155,
        1153,
        1,
        0,
        0,
        0,
        1155,
        1156,
        1,
        0,
        0,
        0,
        1156,
        241,
        1,
        0,
        0,
        0,
        1157,
        1155,
        1,
        0,
        0,
        0,
        1158,
        1159,
        7,
        6,
        0,
        0,
        1159,
        243,
        1,
        0,
        0,
        0,
        1160,
        1164,
        3,
        246,
        123,
        0,
        1161,
        1162,
        5,
        73,
        0,
        0,
        1162,
        1164,
        3,
        244,
        122,
        0,
        1163,
        1160,
        1,
        0,
        0,
        0,
        1163,
        1161,
        1,
        0,
        0,
        0,
        1164,
        245,
        1,
        0,
        0,
        0,
        1165,
        1166,
        6,
        123,
        -1,
        0,
        1166,
        1167,
        3,
        250,
        125,
        0,
        1167,
        1198,
        1,
        0,
        0,
        0,
        1168,
        1169,
        10,
        5,
        0,
        0,
        1169,
        1170,
        5,
        2,
        0,
        0,
        1170,
        1171,
        5,
        31,
        0,
        0,
        1171,
        1172,
        5,
        82,
        0,
        0,
        1172,
        1173,
        3,
        96,
        48,
        0,
        1173,
        1174,
        5,
        83,
        0,
        0,
        1174,
        1197,
        1,
        0,
        0,
        0,
        1175,
        1176,
        10,
        4,
        0,
        0,
        1176,
        1177,
        5,
        2,
        0,
        0,
        1177,
        1178,
        5,
        4,
        0,
        0,
        1178,
        1179,
        5,
        82,
        0,
        0,
        1179,
        1180,
        3,
        96,
        48,
        0,
        1180,
        1181,
        5,
        83,
        0,
        0,
        1181,
        1197,
        1,
        0,
        0,
        0,
        1182,
        1183,
        10,
        3,
        0,
        0,
        1183,
        1184,
        5,
        80,
        0,
        0,
        1184,
        1185,
        3,
        220,
        110,
        0,
        1185,
        1186,
        5,
        81,
        0,
        0,
        1186,
        1197,
        1,
        0,
        0,
        0,
        1187,
        1188,
        10,
        2,
        0,
        0,
        1188,
        1190,
        5,
        82,
        0,
        0,
        1189,
        1191,
        3,
        266,
        133,
        0,
        1190,
        1189,
        1,
        0,
        0,
        0,
        1190,
        1191,
        1,
        0,
        0,
        0,
        1191,
        1192,
        1,
        0,
        0,
        0,
        1192,
        1197,
        5,
        83,
        0,
        0,
        1193,
        1194,
        10,
        1,
        0,
        0,
        1194,
        1195,
        5,
        2,
        0,
        0,
        1195,
        1197,
        3,
        54,
        27,
        0,
        1196,
        1168,
        1,
        0,
        0,
        0,
        1196,
        1175,
        1,
        0,
        0,
        0,
        1196,
        1182,
        1,
        0,
        0,
        0,
        1196,
        1187,
        1,
        0,
        0,
        0,
        1196,
        1193,
        1,
        0,
        0,
        0,
        1197,
        1200,
        1,
        0,
        0,
        0,
        1198,
        1196,
        1,
        0,
        0,
        0,
        1198,
        1199,
        1,
        0,
        0,
        0,
        1199,
        247,
        1,
        0,
        0,
        0,
        1200,
        1198,
        1,
        0,
        0,
        0,
        1201,
        1202,
        3,
        246,
        123,
        0,
        1202,
        1203,
        5,
        2,
        0,
        0,
        1203,
        1204,
        3,
        54,
        27,
        0,
        1204,
        249,
        1,
        0,
        0,
        0,
        1205,
        1213,
        3,
        252,
        126,
        0,
        1206,
        1213,
        5,
        77,
        0,
        0,
        1207,
        1213,
        5,
        93,
        0,
        0,
        1208,
        1209,
        5,
        82,
        0,
        0,
        1209,
        1210,
        3,
        220,
        110,
        0,
        1210,
        1211,
        5,
        83,
        0,
        0,
        1211,
        1213,
        1,
        0,
        0,
        0,
        1212,
        1205,
        1,
        0,
        0,
        0,
        1212,
        1206,
        1,
        0,
        0,
        0,
        1212,
        1207,
        1,
        0,
        0,
        0,
        1212,
        1208,
        1,
        0,
        0,
        0,
        1213,
        251,
        1,
        0,
        0,
        0,
        1214,
        1224,
        3,
        272,
        136,
        0,
        1215,
        1224,
        5,
        88,
        0,
        0,
        1216,
        1224,
        3,
        274,
        137,
        0,
        1217,
        1224,
        5,
        92,
        0,
        0,
        1218,
        1224,
        5,
        87,
        0,
        0,
        1219,
        1224,
        3,
        258,
        129,
        0,
        1220,
        1224,
        3,
        44,
        22,
        0,
        1221,
        1224,
        3,
        254,
        127,
        0,
        1222,
        1224,
        3,
        256,
        128,
        0,
        1223,
        1214,
        1,
        0,
        0,
        0,
        1223,
        1215,
        1,
        0,
        0,
        0,
        1223,
        1216,
        1,
        0,
        0,
        0,
        1223,
        1217,
        1,
        0,
        0,
        0,
        1223,
        1218,
        1,
        0,
        0,
        0,
        1223,
        1219,
        1,
        0,
        0,
        0,
        1223,
        1220,
        1,
        0,
        0,
        0,
        1223,
        1221,
        1,
        0,
        0,
        0,
        1223,
        1222,
        1,
        0,
        0,
        0,
        1224,
        253,
        1,
        0,
        0,
        0,
        1225,
        1226,
        5,
        80,
        0,
        0,
        1226,
        1231,
        3,
        220,
        110,
        0,
        1227,
        1228,
        5,
        8,
        0,
        0,
        1228,
        1230,
        3,
        220,
        110,
        0,
        1229,
        1227,
        1,
        0,
        0,
        0,
        1230,
        1233,
        1,
        0,
        0,
        0,
        1231,
        1229,
        1,
        0,
        0,
        0,
        1231,
        1232,
        1,
        0,
        0,
        0,
        1232,
        1234,
        1,
        0,
        0,
        0,
        1233,
        1231,
        1,
        0,
        0,
        0,
        1234,
        1235,
        5,
        81,
        0,
        0,
        1235,
        255,
        1,
        0,
        0,
        0,
        1236,
        1237,
        5,
        60,
        0,
        0,
        1237,
        1238,
        5,
        82,
        0,
        0,
        1238,
        1239,
        3,
        220,
        110,
        0,
        1239,
        1240,
        5,
        8,
        0,
        0,
        1240,
        1241,
        3,
        220,
        110,
        0,
        1241,
        1242,
        5,
        83,
        0,
        0,
        1242,
        1250,
        1,
        0,
        0,
        0,
        1243,
        1244,
        5,
        80,
        0,
        0,
        1244,
        1245,
        3,
        220,
        110,
        0,
        1245,
        1246,
        5,
        78,
        0,
        0,
        1246,
        1247,
        3,
        220,
        110,
        0,
        1247,
        1248,
        5,
        81,
        0,
        0,
        1248,
        1250,
        1,
        0,
        0,
        0,
        1249,
        1236,
        1,
        0,
        0,
        0,
        1249,
        1243,
        1,
        0,
        0,
        0,
        1250,
        257,
        1,
        0,
        0,
        0,
        1251,
        1252,
        3,
        54,
        27,
        0,
        1252,
        1253,
        5,
        2,
        0,
        0,
        1253,
        1255,
        1,
        0,
        0,
        0,
        1254,
        1251,
        1,
        0,
        0,
        0,
        1255,
        1258,
        1,
        0,
        0,
        0,
        1256,
        1254,
        1,
        0,
        0,
        0,
        1256,
        1257,
        1,
        0,
        0,
        0,
        1257,
        1259,
        1,
        0,
        0,
        0,
        1258,
        1256,
        1,
        0,
        0,
        0,
        1259,
        1260,
        3,
        54,
        27,
        0,
        1260,
        259,
        1,
        0,
        0,
        0,
        1261,
        1266,
        3,
        262,
        131,
        0,
        1262,
        1263,
        5,
        8,
        0,
        0,
        1263,
        1265,
        3,
        262,
        131,
        0,
        1264,
        1262,
        1,
        0,
        0,
        0,
        1265,
        1268,
        1,
        0,
        0,
        0,
        1266,
        1264,
        1,
        0,
        0,
        0,
        1266,
        1267,
        1,
        0,
        0,
        0,
        1267,
        261,
        1,
        0,
        0,
        0,
        1268,
        1266,
        1,
        0,
        0,
        0,
        1269,
        1270,
        3,
        264,
        132,
        0,
        1270,
        1271,
        5,
        9,
        0,
        0,
        1271,
        1274,
        3,
        96,
        48,
        0,
        1272,
        1273,
        5,
        11,
        0,
        0,
        1273,
        1275,
        3,
        144,
        72,
        0,
        1274,
        1272,
        1,
        0,
        0,
        0,
        1274,
        1275,
        1,
        0,
        0,
        0,
        1275,
        263,
        1,
        0,
        0,
        0,
        1276,
        1277,
        5,
        93,
        0,
        0,
        1277,
        265,
        1,
        0,
        0,
        0,
        1278,
        1283,
        3,
        268,
        134,
        0,
        1279,
        1280,
        5,
        8,
        0,
        0,
        1280,
        1282,
        3,
        268,
        134,
        0,
        1281,
        1279,
        1,
        0,
        0,
        0,
        1282,
        1285,
        1,
        0,
        0,
        0,
        1283,
        1281,
        1,
        0,
        0,
        0,
        1283,
        1284,
        1,
        0,
        0,
        0,
        1284,
        1290,
        1,
        0,
        0,
        0,
        1285,
        1283,
        1,
        0,
        0,
        0,
        1286,
        1287,
        5,
        8,
        0,
        0,
        1287,
        1289,
        3,
        270,
        135,
        0,
        1288,
        1286,
        1,
        0,
        0,
        0,
        1289,
        1292,
        1,
        0,
        0,
        0,
        1290,
        1288,
        1,
        0,
        0,
        0,
        1290,
        1291,
        1,
        0,
        0,
        0,
        1291,
        1302,
        1,
        0,
        0,
        0,
        1292,
        1290,
        1,
        0,
        0,
        0,
        1293,
        1298,
        3,
        270,
        135,
        0,
        1294,
        1295,
        5,
        8,
        0,
        0,
        1295,
        1297,
        3,
        270,
        135,
        0,
        1296,
        1294,
        1,
        0,
        0,
        0,
        1297,
        1300,
        1,
        0,
        0,
        0,
        1298,
        1296,
        1,
        0,
        0,
        0,
        1298,
        1299,
        1,
        0,
        0,
        0,
        1299,
        1302,
        1,
        0,
        0,
        0,
        1300,
        1298,
        1,
        0,
        0,
        0,
        1301,
        1278,
        1,
        0,
        0,
        0,
        1301,
        1293,
        1,
        0,
        0,
        0,
        1302,
        267,
        1,
        0,
        0,
        0,
        1303,
        1304,
        3,
        220,
        110,
        0,
        1304,
        269,
        1,
        0,
        0,
        0,
        1305,
        1306,
        3,
        264,
        132,
        0,
        1306,
        1307,
        5,
        9,
        0,
        0,
        1307,
        1308,
        3,
        220,
        110,
        0,
        1308,
        271,
        1,
        0,
        0,
        0,
        1309,
        1312,
        5,
        88,
        0,
        0,
        1310,
        1312,
        3,
        274,
        137,
        0,
        1311,
        1309,
        1,
        0,
        0,
        0,
        1311,
        1310,
        1,
        0,
        0,
        0,
        1312,
        1313,
        1,
        0,
        0,
        0,
        1313,
        1314,
        5,
        93,
        0,
        0,
        1314,
        273,
        1,
        0,
        0,
        0,
        1315,
        1316,
        7,
        7,
        0,
        0,
        1316,
        275,
        1,
        0,
        0,
        0,
        125,
        279,
        285,
        297,
        301,
        311,
        325,
        357,
        361,
        370,
        382,
        388,
        399,
        408,
        425,
        432,
        440,
        445,
        450,
        457,
        466,
        474,
        479,
        484,
        491,
        498,
        505,
        507,
        512,
        517,
        525,
        530,
        539,
        546,
        548,
        553,
        558,
        564,
        569,
        577,
        582,
        588,
        599,
        613,
        619,
        625,
        633,
        640,
        644,
        648,
        653,
        671,
        675,
        681,
        685,
        688,
        703,
        712,
        737,
        747,
        754,
        761,
        765,
        773,
        781,
        783,
        794,
        807,
        813,
        817,
        822,
        840,
        844,
        848,
        853,
        865,
        875,
        881,
        889,
        896,
        901,
        904,
        912,
        916,
        923,
        928,
        933,
        942,
        949,
        965,
        980,
        988,
        993,
        1002,
        1011,
        1015,
        1023,
        1028,
        1033,
        1042,
        1047,
        1075,
        1081,
        1094,
        1102,
        1110,
        1116,
        1127,
        1141,
        1155,
        1163,
        1190,
        1196,
        1198,
        1212,
        1223,
        1231,
        1249,
        1256,
        1266,
        1274,
        1283,
        1290,
        1298,
        1301,
        1311,
    ]


class OpenSCENARIO2Parser(Parser):
    grammarFileName = "OpenSCENARIO2.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]

    sharedContextCache = PredictionContextCache()

    literalNames = [
        "<INVALID>",
        "'import'",
        "'.'",
        "'type'",
        "'is'",
        "'SI'",
        "'unit'",
        "'of'",
        "','",
        "':'",
        "'enum'",
        "'='",
        "'!'",
        "'=='",
        "'struct'",
        "'inherits'",
        "'actor'",
        "'scenario'",
        "'action'",
        "'modifier'",
        "'extend'",
        "'global'",
        "'list'",
        "'int'",
        "'uint'",
        "'float'",
        "'bool'",
        "'string'",
        "'event'",
        "'if'",
        "'@'",
        "'as'",
        "'rise'",
        "'fall'",
        "'elapsed'",
        "'every'",
        "'var'",
        "'sample'",
        "'with'",
        "'keep'",
        "'default'",
        "'hard'",
        "'remove_default'",
        "'on'",
        "'do'",
        "'serial'",
        "'one_of'",
        "'parallel'",
        "'wait'",
        "'emit'",
        "'call'",
        "'until'",
        "'def'",
        "'->'",
        "'expression'",
        "'undefined'",
        "'external'",
        "'only'",
        "'cover'",
        "'record'",
        "'range'",
        "'?'",
        "'=>'",
        "'or'",
        "'and'",
        "'not'",
        "'!='",
        "'<'",
        "'<='",
        "'>'",
        "'>='",
        "'in'",
        "'+'",
        "'-'",
        "'*'",
        "'/'",
        "'%'",
        "'it'",
        "'..'",
        "<INVALID>",
        "'['",
        "']'",
        "'('",
        "')'",
    ]

    symbolicNames = [
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "NEWLINE",
        "OPEN_BRACK",
        "CLOSE_BRACK",
        "OPEN_PAREN",
        "CLOSE_PAREN",
        "SKIP_",
        "BLOCK_COMMENT",
        "LINE_COMMENT",
        "StringLiteral",
        "FloatLiteral",
        "UintLiteral",
        "HexUintLiteral",
        "IntLiteral",
        "BoolLiteral",
        "Identifier",
        "INDENT",
        "DEDENT",
    ]

    RULE_osc_file = 0
    RULE_preludeStatement = 1
    RULE_importStatement = 2
    RULE_importReference = 3
    RULE_structuredIdentifier = 4
    RULE_oscDeclaration = 5
    RULE_physicalTypeDeclaration = 6
    RULE_physicalTypeName = 7
    RULE_baseUnitSpecifier = 8
    RULE_sIBaseUnitSpecifier = 9
    RULE_unitDeclaration = 10
    RULE_unitSpecifier = 11
    RULE_sIUnitSpecifier = 12
    RULE_sIBaseExponentList = 13
    RULE_sIBaseExponent = 14
    RULE_sIFactor = 15
    RULE_sIOffset = 16
    RULE_enumDeclaration = 17
    RULE_enumMemberDecl = 18
    RULE_enumMemberValue = 19
    RULE_enumName = 20
    RULE_enumMemberName = 21
    RULE_enumValueReference = 22
    RULE_inheritsCondition = 23
    RULE_structDeclaration = 24
    RULE_structInherts = 25
    RULE_structMemberDecl = 26
    RULE_fieldName = 27
    RULE_structName = 28
    RULE_actorDeclaration = 29
    RULE_actorInherts = 30
    RULE_actorMemberDecl = 31
    RULE_actorName = 32
    RULE_scenarioDeclaration = 33
    RULE_scenarioInherts = 34
    RULE_scenarioMemberDecl = 35
    RULE_qualifiedBehaviorName = 36
    RULE_behaviorName = 37
    RULE_actionDeclaration = 38
    RULE_actionInherts = 39
    RULE_modifierDeclaration = 40
    RULE_modifierName = 41
    RULE_typeExtension = 42
    RULE_enumTypeExtension = 43
    RULE_structuredTypeExtension = 44
    RULE_extendableTypeName = 45
    RULE_extensionMemberDecl = 46
    RULE_globalParameterDeclaration = 47
    RULE_typeDeclarator = 48
    RULE_nonAggregateTypeDeclarator = 49
    RULE_aggregateTypeDeclarator = 50
    RULE_listTypeDeclarator = 51
    RULE_primitiveType = 52
    RULE_typeName = 53
    RULE_eventDeclaration = 54
    RULE_eventSpecification = 55
    RULE_eventReference = 56
    RULE_eventFieldDecl = 57
    RULE_eventFieldName = 58
    RULE_eventName = 59
    RULE_eventPath = 60
    RULE_eventCondition = 61
    RULE_riseExpression = 62
    RULE_fallExpression = 63
    RULE_elapsedExpression = 64
    RULE_everyExpression = 65
    RULE_boolExpression = 66
    RULE_durationExpression = 67
    RULE_fieldDeclaration = 68
    RULE_parameterDeclaration = 69
    RULE_variableDeclaration = 70
    RULE_sampleExpression = 71
    RULE_defaultValue = 72
    RULE_parameterWithDeclaration = 73
    RULE_parameterWithMember = 74
    RULE_constraintDeclaration = 75
    RULE_keepConstraintDeclaration = 76
    RULE_constraintQualifier = 77
    RULE_constraintExpression = 78
    RULE_removeDefaultDeclaration = 79
    RULE_parameterReference = 80
    RULE_modifierInvocation = 81
    RULE_behaviorExpression = 82
    RULE_behaviorSpecification = 83
    RULE_onDirective = 84
    RULE_onMember = 85
    RULE_doDirective = 86
    RULE_doMember = 87
    RULE_composition = 88
    RULE_compositionOperator = 89
    RULE_behaviorInvocation = 90
    RULE_behaviorWithDeclaration = 91
    RULE_behaviorWithMember = 92
    RULE_labelName = 93
    RULE_actorExpression = 94
    RULE_waitDirective = 95
    RULE_emitDirective = 96
    RULE_callDirective = 97
    RULE_untilDirective = 98
    RULE_methodInvocation = 99
    RULE_methodDeclaration = 100
    RULE_returnType = 101
    RULE_methodImplementation = 102
    RULE_methodQualifier = 103
    RULE_methodName = 104
    RULE_coverageDeclaration = 105
    RULE_coverDeclaration = 106
    RULE_recordDeclaration = 107
    RULE_coverageArgumentList = 108
    RULE_targetName = 109
    RULE_expression = 110
    RULE_ternaryOpExp = 111
    RULE_implication = 112
    RULE_disjunction = 113
    RULE_conjunction = 114
    RULE_inversion = 115
    RULE_relation = 116
    RULE_relationalOp = 117
    RULE_sum = 118
    RULE_additiveOp = 119
    RULE_term = 120
    RULE_multiplicativeOp = 121
    RULE_factor = 122
    RULE_postfixExp = 123
    RULE_fieldAccess = 124
    RULE_primaryExp = 125
    RULE_valueExp = 126
    RULE_listConstructor = 127
    RULE_rangeConstructor = 128
    RULE_identifierReference = 129
    RULE_argumentListSpecification = 130
    RULE_argumentSpecification = 131
    RULE_argumentName = 132
    RULE_argumentList = 133
    RULE_positionalArgument = 134
    RULE_namedArgument = 135
    RULE_physicalLiteral = 136
    RULE_integerLiteral = 137

    ruleNames = [
        "osc_file",
        "preludeStatement",
        "importStatement",
        "importReference",
        "structuredIdentifier",
        "oscDeclaration",
        "physicalTypeDeclaration",
        "physicalTypeName",
        "baseUnitSpecifier",
        "sIBaseUnitSpecifier",
        "unitDeclaration",
        "unitSpecifier",
        "sIUnitSpecifier",
        "sIBaseExponentList",
        "sIBaseExponent",
        "sIFactor",
        "sIOffset",
        "enumDeclaration",
        "enumMemberDecl",
        "enumMemberValue",
        "enumName",
        "enumMemberName",
        "enumValueReference",
        "inheritsCondition",
        "structDeclaration",
        "structInherts",
        "structMemberDecl",
        "fieldName",
        "structName",
        "actorDeclaration",
        "actorInherts",
        "actorMemberDecl",
        "actorName",
        "scenarioDeclaration",
        "scenarioInherts",
        "scenarioMemberDecl",
        "qualifiedBehaviorName",
        "behaviorName",
        "actionDeclaration",
        "actionInherts",
        "modifierDeclaration",
        "modifierName",
        "typeExtension",
        "enumTypeExtension",
        "structuredTypeExtension",
        "extendableTypeName",
        "extensionMemberDecl",
        "globalParameterDeclaration",
        "typeDeclarator",
        "nonAggregateTypeDeclarator",
        "aggregateTypeDeclarator",
        "listTypeDeclarator",
        "primitiveType",
        "typeName",
        "eventDeclaration",
        "eventSpecification",
        "eventReference",
        "eventFieldDecl",
        "eventFieldName",
        "eventName",
        "eventPath",
        "eventCondition",
        "riseExpression",
        "fallExpression",
        "elapsedExpression",
        "everyExpression",
        "boolExpression",
        "durationExpression",
        "fieldDeclaration",
        "parameterDeclaration",
        "variableDeclaration",
        "sampleExpression",
        "defaultValue",
        "parameterWithDeclaration",
        "parameterWithMember",
        "constraintDeclaration",
        "keepConstraintDeclaration",
        "constraintQualifier",
        "constraintExpression",
        "removeDefaultDeclaration",
        "parameterReference",
        "modifierInvocation",
        "behaviorExpression",
        "behaviorSpecification",
        "onDirective",
        "onMember",
        "doDirective",
        "doMember",
        "composition",
        "compositionOperator",
        "behaviorInvocation",
        "behaviorWithDeclaration",
        "behaviorWithMember",
        "labelName",
        "actorExpression",
        "waitDirective",
        "emitDirective",
        "callDirective",
        "untilDirective",
        "methodInvocation",
        "methodDeclaration",
        "returnType",
        "methodImplementation",
        "methodQualifier",
        "methodName",
        "coverageDeclaration",
        "coverDeclaration",
        "recordDeclaration",
        "coverageArgumentList",
        "targetName",
        "expression",
        "ternaryOpExp",
        "implication",
        "disjunction",
        "conjunction",
        "inversion",
        "relation",
        "relationalOp",
        "sum",
        "additiveOp",
        "term",
        "multiplicativeOp",
        "factor",
        "postfixExp",
        "fieldAccess",
        "primaryExp",
        "valueExp",
        "listConstructor",
        "rangeConstructor",
        "identifierReference",
        "argumentListSpecification",
        "argumentSpecification",
        "argumentName",
        "argumentList",
        "positionalArgument",
        "namedArgument",
        "physicalLiteral",
        "integerLiteral",
    ]

    EOF = Token.EOF
    T__0 = 1
    T__1 = 2
    T__2 = 3
    T__3 = 4
    T__4 = 5
    T__5 = 6
    T__6 = 7
    T__7 = 8
    T__8 = 9
    T__9 = 10
    T__10 = 11
    T__11 = 12
    T__12 = 13
    T__13 = 14
    T__14 = 15
    T__15 = 16
    T__16 = 17
    T__17 = 18
    T__18 = 19
    T__19 = 20
    T__20 = 21
    T__21 = 22
    T__22 = 23
    T__23 = 24
    T__24 = 25
    T__25 = 26
    T__26 = 27
    T__27 = 28
    T__28 = 29
    T__29 = 30
    T__30 = 31
    T__31 = 32
    T__32 = 33
    T__33 = 34
    T__34 = 35
    T__35 = 36
    T__36 = 37
    T__37 = 38
    T__38 = 39
    T__39 = 40
    T__40 = 41
    T__41 = 42
    T__42 = 43
    T__43 = 44
    T__44 = 45
    T__45 = 46
    T__46 = 47
    T__47 = 48
    T__48 = 49
    T__49 = 50
    T__50 = 51
    T__51 = 52
    T__52 = 53
    T__53 = 54
    T__54 = 55
    T__55 = 56
    T__56 = 57
    T__57 = 58
    T__58 = 59
    T__59 = 60
    T__60 = 61
    T__61 = 62
    T__62 = 63
    T__63 = 64
    T__64 = 65
    T__65 = 66
    T__66 = 67
    T__67 = 68
    T__68 = 69
    T__69 = 70
    T__70 = 71
    T__71 = 72
    T__72 = 73
    T__73 = 74
    T__74 = 75
    T__75 = 76
    T__76 = 77
    T__77 = 78
    NEWLINE = 79
    OPEN_BRACK = 80
    CLOSE_BRACK = 81
    OPEN_PAREN = 82
    CLOSE_PAREN = 83
    SKIP_ = 84
    BLOCK_COMMENT = 85
    LINE_COMMENT = 86
    StringLiteral = 87
    FloatLiteral = 88
    UintLiteral = 89
    HexUintLiteral = 90
    IntLiteral = 91
    BoolLiteral = 92
    Identifier = 93
    INDENT = 94
    DEDENT = 95

    def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.10.1")
        self._interp = ParserATNSimulator(
            self, self.atn, self.decisionsToDFA, self.sharedContextCache
        )
        self._predicates = None

    class Osc_fileContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(OpenSCENARIO2Parser.EOF, 0)

        def preludeStatement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.PreludeStatementContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.PreludeStatementContext, i
                )

        def oscDeclaration(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.OscDeclarationContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.OscDeclarationContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_osc_file

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterOsc_file"):
                listener.enterOsc_file(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitOsc_file"):
                listener.exitOsc_file(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitOsc_file"):
                return visitor.visitOsc_file(self)
            else:
                return visitor.visitChildren(self)

    def osc_file(self):
        localctx = OpenSCENARIO2Parser.Osc_fileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_osc_file)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 279
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 0, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 276
                    self.preludeStatement()
                self.state = 281
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 0, self._ctx)

            self.state = 285
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << OpenSCENARIO2Parser.T__2)
                        | (1 << OpenSCENARIO2Parser.T__5)
                        | (1 << OpenSCENARIO2Parser.T__9)
                        | (1 << OpenSCENARIO2Parser.T__13)
                        | (1 << OpenSCENARIO2Parser.T__15)
                        | (1 << OpenSCENARIO2Parser.T__16)
                        | (1 << OpenSCENARIO2Parser.T__17)
                        | (1 << OpenSCENARIO2Parser.T__18)
                        | (1 << OpenSCENARIO2Parser.T__19)
                        | (1 << OpenSCENARIO2Parser.T__20)
                    )
                )
                != 0
            ) or _la == OpenSCENARIO2Parser.NEWLINE:
                self.state = 282
                self.oscDeclaration()
                self.state = 287
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 288
            self.match(OpenSCENARIO2Parser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PreludeStatementContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def importStatement(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ImportStatementContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_preludeStatement

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPreludeStatement"):
                listener.enterPreludeStatement(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPreludeStatement"):
                listener.exitPreludeStatement(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPreludeStatement"):
                return visitor.visitPreludeStatement(self)
            else:
                return visitor.visitChildren(self)

    def preludeStatement(self):
        localctx = OpenSCENARIO2Parser.PreludeStatementContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 2, self.RULE_preludeStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 290
            self.importStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ImportStatementContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def importReference(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ImportReferenceContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_importStatement

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterImportStatement"):
                listener.enterImportStatement(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitImportStatement"):
                listener.exitImportStatement(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitImportStatement"):
                return visitor.visitImportStatement(self)
            else:
                return visitor.visitChildren(self)

    def importStatement(self):
        localctx = OpenSCENARIO2Parser.ImportStatementContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 4, self.RULE_importStatement)
        try:
            self.state = 297
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__0]:
                self.enterOuterAlt(localctx, 1)
                self.state = 292
                self.match(OpenSCENARIO2Parser.T__0)
                self.state = 293
                self.importReference()
                self.state = 294
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 296
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ImportReferenceContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def StringLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.StringLiteral, 0)

        def structuredIdentifier(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.StructuredIdentifierContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_importReference

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterImportReference"):
                listener.enterImportReference(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitImportReference"):
                listener.exitImportReference(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitImportReference"):
                return visitor.visitImportReference(self)
            else:
                return visitor.visitChildren(self)

    def importReference(self):
        localctx = OpenSCENARIO2Parser.ImportReferenceContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 6, self.RULE_importReference)
        try:
            self.state = 301
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.StringLiteral]:
                self.enterOuterAlt(localctx, 1)
                self.state = 299
                self.match(OpenSCENARIO2Parser.StringLiteral)
                pass
            elif token in [OpenSCENARIO2Parser.Identifier]:
                self.enterOuterAlt(localctx, 2)
                self.state = 300
                self.structuredIdentifier(0)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StructuredIdentifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def structuredIdentifier(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.StructuredIdentifierContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_structuredIdentifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterStructuredIdentifier"):
                listener.enterStructuredIdentifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitStructuredIdentifier"):
                listener.exitStructuredIdentifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStructuredIdentifier"):
                return visitor.visitStructuredIdentifier(self)
            else:
                return visitor.visitChildren(self)

    def structuredIdentifier(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = OpenSCENARIO2Parser.StructuredIdentifierContext(
            self, self._ctx, _parentState
        )
        _prevctx = localctx
        _startState = 8
        self.enterRecursionRule(localctx, 8, self.RULE_structuredIdentifier, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 304
            self.match(OpenSCENARIO2Parser.Identifier)
            self._ctx.stop = self._input.LT(-1)
            self.state = 311
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 4, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = OpenSCENARIO2Parser.StructuredIdentifierContext(
                        self, _parentctx, _parentState
                    )
                    self.pushNewRecursionContext(
                        localctx, _startState, self.RULE_structuredIdentifier
                    )
                    self.state = 306
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException

                        raise FailedPredicateException(
                            self, "self.precpred(self._ctx, 1)"
                        )
                    self.state = 307
                    self.match(OpenSCENARIO2Parser.T__1)
                    self.state = 308
                    self.match(OpenSCENARIO2Parser.Identifier)
                self.state = 313
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 4, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx

    class OscDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def physicalTypeDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.PhysicalTypeDeclarationContext, 0
            )

        def unitDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.UnitDeclarationContext, 0
            )

        def enumDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EnumDeclarationContext, 0
            )

        def structDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.StructDeclarationContext, 0
            )

        def actorDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ActorDeclarationContext, 0
            )

        def actionDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ActionDeclarationContext, 0
            )

        def scenarioDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ScenarioDeclarationContext, 0
            )

        def modifierDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ModifierDeclarationContext, 0
            )

        def typeExtension(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TypeExtensionContext, 0)

        def globalParameterDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.GlobalParameterDeclarationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_oscDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterOscDeclaration"):
                listener.enterOscDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitOscDeclaration"):
                listener.exitOscDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitOscDeclaration"):
                return visitor.visitOscDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def oscDeclaration(self):
        localctx = OpenSCENARIO2Parser.OscDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 10, self.RULE_oscDeclaration)
        try:
            self.state = 325
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__2]:
                self.enterOuterAlt(localctx, 1)
                self.state = 314
                self.physicalTypeDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__5]:
                self.enterOuterAlt(localctx, 2)
                self.state = 315
                self.unitDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 316
                self.enumDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__13]:
                self.enterOuterAlt(localctx, 4)
                self.state = 317
                self.structDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__15]:
                self.enterOuterAlt(localctx, 5)
                self.state = 318
                self.actorDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__17]:
                self.enterOuterAlt(localctx, 6)
                self.state = 319
                self.actionDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__16]:
                self.enterOuterAlt(localctx, 7)
                self.state = 320
                self.scenarioDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__18]:
                self.enterOuterAlt(localctx, 8)
                self.state = 321
                self.modifierDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__19]:
                self.enterOuterAlt(localctx, 9)
                self.state = 322
                self.typeExtension()
                pass
            elif token in [OpenSCENARIO2Parser.T__20]:
                self.enterOuterAlt(localctx, 10)
                self.state = 323
                self.globalParameterDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.enterOuterAlt(localctx, 11)
                self.state = 324
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PhysicalTypeDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def physicalTypeName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.PhysicalTypeNameContext, 0
            )

        def baseUnitSpecifier(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BaseUnitSpecifierContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_physicalTypeDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPhysicalTypeDeclaration"):
                listener.enterPhysicalTypeDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPhysicalTypeDeclaration"):
                listener.exitPhysicalTypeDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPhysicalTypeDeclaration"):
                return visitor.visitPhysicalTypeDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def physicalTypeDeclaration(self):
        localctx = OpenSCENARIO2Parser.PhysicalTypeDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 12, self.RULE_physicalTypeDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.match(OpenSCENARIO2Parser.T__2)
            self.state = 328
            self.physicalTypeName()
            self.state = 329
            self.match(OpenSCENARIO2Parser.T__3)
            self.state = 330
            self.baseUnitSpecifier()
            self.state = 331
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PhysicalTypeNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_physicalTypeName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPhysicalTypeName"):
                listener.enterPhysicalTypeName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPhysicalTypeName"):
                listener.exitPhysicalTypeName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPhysicalTypeName"):
                return visitor.visitPhysicalTypeName(self)
            else:
                return visitor.visitChildren(self)

    def physicalTypeName(self):
        localctx = OpenSCENARIO2Parser.PhysicalTypeNameContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 14, self.RULE_physicalTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 333
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BaseUnitSpecifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def sIBaseUnitSpecifier(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.SIBaseUnitSpecifierContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_baseUnitSpecifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBaseUnitSpecifier"):
                listener.enterBaseUnitSpecifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBaseUnitSpecifier"):
                listener.exitBaseUnitSpecifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBaseUnitSpecifier"):
                return visitor.visitBaseUnitSpecifier(self)
            else:
                return visitor.visitChildren(self)

    def baseUnitSpecifier(self):
        localctx = OpenSCENARIO2Parser.BaseUnitSpecifierContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 16, self.RULE_baseUnitSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 335
            self.sIBaseUnitSpecifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SIBaseUnitSpecifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def sIBaseExponentList(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.SIBaseExponentListContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_sIBaseUnitSpecifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSIBaseUnitSpecifier"):
                listener.enterSIBaseUnitSpecifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSIBaseUnitSpecifier"):
                listener.exitSIBaseUnitSpecifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSIBaseUnitSpecifier"):
                return visitor.visitSIBaseUnitSpecifier(self)
            else:
                return visitor.visitChildren(self)

    def sIBaseUnitSpecifier(self):
        localctx = OpenSCENARIO2Parser.SIBaseUnitSpecifierContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 18, self.RULE_sIBaseUnitSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 337
            self.match(OpenSCENARIO2Parser.T__4)
            self.state = 338
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 339
            self.sIBaseExponentList()
            self.state = 340
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class UnitDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.unitName = None  # Token

        def physicalTypeName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.PhysicalTypeNameContext, 0
            )

        def unitSpecifier(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.UnitSpecifierContext, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_unitDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterUnitDeclaration"):
                listener.enterUnitDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitUnitDeclaration"):
                listener.exitUnitDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitUnitDeclaration"):
                return visitor.visitUnitDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def unitDeclaration(self):
        localctx = OpenSCENARIO2Parser.UnitDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 20, self.RULE_unitDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 342
            self.match(OpenSCENARIO2Parser.T__5)
            self.state = 343
            localctx.unitName = self.match(OpenSCENARIO2Parser.Identifier)
            self.state = 344
            self.match(OpenSCENARIO2Parser.T__6)
            self.state = 345
            self.physicalTypeName()
            self.state = 346
            self.match(OpenSCENARIO2Parser.T__3)
            self.state = 347
            self.unitSpecifier()
            self.state = 348
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class UnitSpecifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def sIUnitSpecifier(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.SIUnitSpecifierContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_unitSpecifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterUnitSpecifier"):
                listener.enterUnitSpecifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitUnitSpecifier"):
                listener.exitUnitSpecifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitUnitSpecifier"):
                return visitor.visitUnitSpecifier(self)
            else:
                return visitor.visitChildren(self)

    def unitSpecifier(self):
        localctx = OpenSCENARIO2Parser.UnitSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_unitSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 350
            self.sIUnitSpecifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SIUnitSpecifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def sIBaseExponentList(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.SIBaseExponentListContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def sIFactor(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.SIFactorContext, 0)

        def sIOffset(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.SIOffsetContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_sIUnitSpecifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSIUnitSpecifier"):
                listener.enterSIUnitSpecifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSIUnitSpecifier"):
                listener.exitSIUnitSpecifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSIUnitSpecifier"):
                return visitor.visitSIUnitSpecifier(self)
            else:
                return visitor.visitChildren(self)

    def sIUnitSpecifier(self):
        localctx = OpenSCENARIO2Parser.SIUnitSpecifierContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 24, self.RULE_sIUnitSpecifier)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 352
            self.match(OpenSCENARIO2Parser.T__4)
            self.state = 353
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 354
            self.sIBaseExponentList()
            self.state = 357
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 6, self._ctx)
            if la_ == 1:
                self.state = 355
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 356
                self.sIFactor()

            self.state = 361
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__7:
                self.state = 359
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 360
                self.sIOffset()

            self.state = 363
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SIBaseExponentListContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def sIBaseExponent(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.SIBaseExponentContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.SIBaseExponentContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_sIBaseExponentList

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSIBaseExponentList"):
                listener.enterSIBaseExponentList(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSIBaseExponentList"):
                listener.exitSIBaseExponentList(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSIBaseExponentList"):
                return visitor.visitSIBaseExponentList(self)
            else:
                return visitor.visitChildren(self)

    def sIBaseExponentList(self):
        localctx = OpenSCENARIO2Parser.SIBaseExponentListContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 26, self.RULE_sIBaseExponentList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 365
            self.sIBaseExponent()
            self.state = 370
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 8, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 366
                    self.match(OpenSCENARIO2Parser.T__7)
                    self.state = 367
                    self.sIBaseExponent()
                self.state = 372
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 8, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SIBaseExponentContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.sIBaseUnitName = None  # Token

        def integerLiteral(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.IntegerLiteralContext, 0
            )

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_sIBaseExponent

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSIBaseExponent"):
                listener.enterSIBaseExponent(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSIBaseExponent"):
                listener.exitSIBaseExponent(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSIBaseExponent"):
                return visitor.visitSIBaseExponent(self)
            else:
                return visitor.visitChildren(self)

    def sIBaseExponent(self):
        localctx = OpenSCENARIO2Parser.SIBaseExponentContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 28, self.RULE_sIBaseExponent)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 373
            localctx.sIBaseUnitName = self.match(OpenSCENARIO2Parser.Identifier)

            unitName = (
                None
                if localctx.sIBaseUnitName is None
                else localctx.sIBaseUnitName.text
            )
            if (
                not (unitName == "kg")
                and not (unitName == "m")
                and not (unitName == "s")
                and not (unitName == "A")
                and not (unitName == "K")
                and not (unitName == "mol")
                and not (unitName == "cd")
                and not (unitName == "factor")
                and not (unitName == "offset")
                and not (unitName == "rad")
            ):
                print("unit name %s is not supported" % unitName)
                raise NoViableAltException(self)

            self.state = 375
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 376
            self.integerLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SIFactorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def FloatLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.FloatLiteral, 0)

        def integerLiteral(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.IntegerLiteralContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_sIFactor

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSIFactor"):
                listener.enterSIFactor(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSIFactor"):
                listener.exitSIFactor(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSIFactor"):
                return visitor.visitSIFactor(self)
            else:
                return visitor.visitChildren(self)

    def sIFactor(self):
        localctx = OpenSCENARIO2Parser.SIFactorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_sIFactor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            self.match(OpenSCENARIO2Parser.Identifier)
            self.state = 379
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 382
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.FloatLiteral]:
                self.state = 380
                self.match(OpenSCENARIO2Parser.FloatLiteral)
                pass
            elif token in [
                OpenSCENARIO2Parser.UintLiteral,
                OpenSCENARIO2Parser.HexUintLiteral,
                OpenSCENARIO2Parser.IntLiteral,
            ]:
                self.state = 381
                self.integerLiteral()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SIOffsetContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def FloatLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.FloatLiteral, 0)

        def integerLiteral(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.IntegerLiteralContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_sIOffset

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSIOffset"):
                listener.enterSIOffset(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSIOffset"):
                listener.exitSIOffset(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSIOffset"):
                return visitor.visitSIOffset(self)
            else:
                return visitor.visitChildren(self)

    def sIOffset(self):
        localctx = OpenSCENARIO2Parser.SIOffsetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_sIOffset)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 384
            self.match(OpenSCENARIO2Parser.Identifier)
            self.state = 385
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 388
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.FloatLiteral]:
                self.state = 386
                self.match(OpenSCENARIO2Parser.FloatLiteral)
                pass
            elif token in [
                OpenSCENARIO2Parser.UintLiteral,
                OpenSCENARIO2Parser.HexUintLiteral,
                OpenSCENARIO2Parser.IntLiteral,
            ]:
                self.state = 387
                self.integerLiteral()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EnumNameContext, 0)

        def OPEN_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_BRACK, 0)

        def enumMemberDecl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.EnumMemberDeclContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.EnumMemberDeclContext, i
                )

        def CLOSE_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_BRACK, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_enumDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumDeclaration"):
                listener.enterEnumDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumDeclaration"):
                listener.exitEnumDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumDeclaration"):
                return visitor.visitEnumDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def enumDeclaration(self):
        localctx = OpenSCENARIO2Parser.EnumDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 34, self.RULE_enumDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 390
            self.match(OpenSCENARIO2Parser.T__9)
            self.state = 391
            self.enumName()
            self.state = 392
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 393
            self.match(OpenSCENARIO2Parser.OPEN_BRACK)
            self.state = 394
            self.enumMemberDecl()
            self.state = 399
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 395
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 396
                self.enumMemberDecl()
                self.state = 401
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 402
            self.match(OpenSCENARIO2Parser.CLOSE_BRACK)
            self.state = 403
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumMemberDeclContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumMemberName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EnumMemberNameContext, 0
            )

        def enumMemberValue(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EnumMemberValueContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_enumMemberDecl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumMemberDecl"):
                listener.enterEnumMemberDecl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumMemberDecl"):
                listener.exitEnumMemberDecl(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumMemberDecl"):
                return visitor.visitEnumMemberDecl(self)
            else:
                return visitor.visitChildren(self)

    def enumMemberDecl(self):
        localctx = OpenSCENARIO2Parser.EnumMemberDeclContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 36, self.RULE_enumMemberDecl)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 405
            self.enumMemberName()
            self.state = 408
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__10:
                self.state = 406
                self.match(OpenSCENARIO2Parser.T__10)
                self.state = 407
                self.enumMemberValue()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumMemberValueContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UintLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.UintLiteral, 0)

        def HexUintLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.HexUintLiteral, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_enumMemberValue

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumMemberValue"):
                listener.enterEnumMemberValue(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumMemberValue"):
                listener.exitEnumMemberValue(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumMemberValue"):
                return visitor.visitEnumMemberValue(self)
            else:
                return visitor.visitChildren(self)

    def enumMemberValue(self):
        localctx = OpenSCENARIO2Parser.EnumMemberValueContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 38, self.RULE_enumMemberValue)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 410
            _la = self._input.LA(1)
            if not (
                _la == OpenSCENARIO2Parser.UintLiteral
                or _la == OpenSCENARIO2Parser.HexUintLiteral
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_enumName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumName"):
                listener.enterEnumName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumName"):
                listener.exitEnumName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumName"):
                return visitor.visitEnumName(self)
            else:
                return visitor.visitChildren(self)

    def enumName(self):
        localctx = OpenSCENARIO2Parser.EnumNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_enumName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 412
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumMemberNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_enumMemberName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumMemberName"):
                listener.enterEnumMemberName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumMemberName"):
                listener.exitEnumMemberName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumMemberName"):
                return visitor.visitEnumMemberName(self)
            else:
                return visitor.visitChildren(self)

    def enumMemberName(self):
        localctx = OpenSCENARIO2Parser.EnumMemberNameContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 42, self.RULE_enumMemberName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 414
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumValueReferenceContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EnumNameContext, 0)

        def enumMemberName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EnumMemberNameContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_enumValueReference

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumValueReference"):
                listener.enterEnumValueReference(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumValueReference"):
                listener.exitEnumValueReference(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumValueReference"):
                return visitor.visitEnumValueReference(self)
            else:
                return visitor.visitChildren(self)

    def enumValueReference(self):
        localctx = OpenSCENARIO2Parser.EnumValueReferenceContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 44, self.RULE_enumValueReference)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 416
            self.enumName()
            self.state = 417
            self.match(OpenSCENARIO2Parser.T__11)
            self.state = 418
            self.enumMemberName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InheritsConditionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def fieldName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldNameContext, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def enumValueReference(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EnumValueReferenceContext, 0
            )

        def BoolLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.BoolLiteral, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_inheritsCondition

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInheritsCondition"):
                listener.enterInheritsCondition(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInheritsCondition"):
                listener.exitInheritsCondition(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInheritsCondition"):
                return visitor.visitInheritsCondition(self)
            else:
                return visitor.visitChildren(self)

    def inheritsCondition(self):
        localctx = OpenSCENARIO2Parser.InheritsConditionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 46, self.RULE_inheritsCondition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 420
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 421
            self.fieldName()
            self.state = 422
            self.match(OpenSCENARIO2Parser.T__12)
            self.state = 425
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.Identifier]:
                self.state = 423
                self.enumValueReference()
                pass
            elif token in [OpenSCENARIO2Parser.BoolLiteral]:
                self.state = 424
                self.match(OpenSCENARIO2Parser.BoolLiteral)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 427
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StructDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def structName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.StructNameContext, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def structInherts(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.StructInhertsContext, 0)

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def structMemberDecl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.StructMemberDeclContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.StructMemberDeclContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_structDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterStructDeclaration"):
                listener.enterStructDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitStructDeclaration"):
                listener.exitStructDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStructDeclaration"):
                return visitor.visitStructDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def structDeclaration(self):
        localctx = OpenSCENARIO2Parser.StructDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 48, self.RULE_structDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 429
            self.match(OpenSCENARIO2Parser.T__13)
            self.state = 430
            self.structName()
            self.state = 432
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__14:
                self.state = 431
                self.structInherts()

            self.state = 445
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__8]:
                self.state = 434
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 435
                self.match(OpenSCENARIO2Parser.NEWLINE)
                self.state = 436
                self.match(OpenSCENARIO2Parser.INDENT)
                self.state = 438
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 437
                    self.structMemberDecl()
                    self.state = 440
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << OpenSCENARIO2Parser.T__27)
                                    | (1 << OpenSCENARIO2Parser.T__35)
                                    | (1 << OpenSCENARIO2Parser.T__38)
                                    | (1 << OpenSCENARIO2Parser.T__41)
                                    | (1 << OpenSCENARIO2Parser.T__51)
                                    | (1 << OpenSCENARIO2Parser.T__57)
                                    | (1 << OpenSCENARIO2Parser.T__58)
                                )
                            )
                            != 0
                        )
                        or _la == OpenSCENARIO2Parser.Identifier
                    ):
                        break

                self.state = 442
                self.match(OpenSCENARIO2Parser.DEDENT)
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.state = 444
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StructInhertsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def structName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.StructNameContext, 0)

        def inheritsCondition(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.InheritsConditionContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_structInherts

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterStructInherts"):
                listener.enterStructInherts(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitStructInherts"):
                listener.exitStructInherts(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStructInherts"):
                return visitor.visitStructInherts(self)
            else:
                return visitor.visitChildren(self)

    def structInherts(self):
        localctx = OpenSCENARIO2Parser.StructInhertsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_structInherts)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 447
            self.match(OpenSCENARIO2Parser.T__14)
            self.state = 448
            self.structName()
            self.state = 450
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.OPEN_PAREN:
                self.state = 449
                self.inheritsCondition()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StructMemberDeclContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventDeclarationContext, 0
            )

        def fieldDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.FieldDeclarationContext, 0
            )

        def constraintDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ConstraintDeclarationContext, 0
            )

        def methodDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.MethodDeclarationContext, 0
            )

        def coverageDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.CoverageDeclarationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_structMemberDecl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterStructMemberDecl"):
                listener.enterStructMemberDecl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitStructMemberDecl"):
                listener.exitStructMemberDecl(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStructMemberDecl"):
                return visitor.visitStructMemberDecl(self)
            else:
                return visitor.visitChildren(self)

    def structMemberDecl(self):
        localctx = OpenSCENARIO2Parser.StructMemberDeclContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 52, self.RULE_structMemberDecl)
        try:
            self.state = 457
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__27]:
                self.enterOuterAlt(localctx, 1)
                self.state = 452
                self.eventDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__35, OpenSCENARIO2Parser.Identifier]:
                self.enterOuterAlt(localctx, 2)
                self.state = 453
                self.fieldDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__38, OpenSCENARIO2Parser.T__41]:
                self.enterOuterAlt(localctx, 3)
                self.state = 454
                self.constraintDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__51]:
                self.enterOuterAlt(localctx, 4)
                self.state = 455
                self.methodDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__57, OpenSCENARIO2Parser.T__58]:
                self.enterOuterAlt(localctx, 5)
                self.state = 456
                self.coverageDeclaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FieldNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_fieldName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFieldName"):
                listener.enterFieldName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFieldName"):
                listener.exitFieldName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFieldName"):
                return visitor.visitFieldName(self)
            else:
                return visitor.visitChildren(self)

    def fieldName(self):
        localctx = OpenSCENARIO2Parser.FieldNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_fieldName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 459
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StructNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_structName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterStructName"):
                listener.enterStructName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitStructName"):
                listener.exitStructName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStructName"):
                return visitor.visitStructName(self)
            else:
                return visitor.visitChildren(self)

    def structName(self):
        localctx = OpenSCENARIO2Parser.StructNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_structName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 461
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ActorDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def actorName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ActorNameContext, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def actorInherts(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ActorInhertsContext, 0)

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def actorMemberDecl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.ActorMemberDeclContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ActorMemberDeclContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_actorDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterActorDeclaration"):
                listener.enterActorDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitActorDeclaration"):
                listener.exitActorDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActorDeclaration"):
                return visitor.visitActorDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def actorDeclaration(self):
        localctx = OpenSCENARIO2Parser.ActorDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 58, self.RULE_actorDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 463
            self.match(OpenSCENARIO2Parser.T__15)
            self.state = 464
            self.actorName()
            self.state = 466
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__14:
                self.state = 465
                self.actorInherts()

            self.state = 479
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__8]:
                self.state = 468
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 469
                self.match(OpenSCENARIO2Parser.NEWLINE)
                self.state = 470
                self.match(OpenSCENARIO2Parser.INDENT)
                self.state = 472
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 471
                    self.actorMemberDecl()
                    self.state = 474
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << OpenSCENARIO2Parser.T__27)
                                    | (1 << OpenSCENARIO2Parser.T__35)
                                    | (1 << OpenSCENARIO2Parser.T__38)
                                    | (1 << OpenSCENARIO2Parser.T__41)
                                    | (1 << OpenSCENARIO2Parser.T__51)
                                    | (1 << OpenSCENARIO2Parser.T__57)
                                    | (1 << OpenSCENARIO2Parser.T__58)
                                )
                            )
                            != 0
                        )
                        or _la == OpenSCENARIO2Parser.Identifier
                    ):
                        break

                self.state = 476
                self.match(OpenSCENARIO2Parser.DEDENT)
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.state = 478
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ActorInhertsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def actorName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ActorNameContext, 0)

        def inheritsCondition(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.InheritsConditionContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_actorInherts

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterActorInherts"):
                listener.enterActorInherts(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitActorInherts"):
                listener.exitActorInherts(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActorInherts"):
                return visitor.visitActorInherts(self)
            else:
                return visitor.visitChildren(self)

    def actorInherts(self):
        localctx = OpenSCENARIO2Parser.ActorInhertsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_actorInherts)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 481
            self.match(OpenSCENARIO2Parser.T__14)
            self.state = 482
            self.actorName()
            self.state = 484
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.OPEN_PAREN:
                self.state = 483
                self.inheritsCondition()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ActorMemberDeclContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventDeclarationContext, 0
            )

        def fieldDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.FieldDeclarationContext, 0
            )

        def constraintDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ConstraintDeclarationContext, 0
            )

        def methodDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.MethodDeclarationContext, 0
            )

        def coverageDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.CoverageDeclarationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_actorMemberDecl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterActorMemberDecl"):
                listener.enterActorMemberDecl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitActorMemberDecl"):
                listener.exitActorMemberDecl(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActorMemberDecl"):
                return visitor.visitActorMemberDecl(self)
            else:
                return visitor.visitChildren(self)

    def actorMemberDecl(self):
        localctx = OpenSCENARIO2Parser.ActorMemberDeclContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 62, self.RULE_actorMemberDecl)
        try:
            self.state = 491
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__27]:
                self.enterOuterAlt(localctx, 1)
                self.state = 486
                self.eventDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__35, OpenSCENARIO2Parser.Identifier]:
                self.enterOuterAlt(localctx, 2)
                self.state = 487
                self.fieldDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__38, OpenSCENARIO2Parser.T__41]:
                self.enterOuterAlt(localctx, 3)
                self.state = 488
                self.constraintDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__51]:
                self.enterOuterAlt(localctx, 4)
                self.state = 489
                self.methodDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__57, OpenSCENARIO2Parser.T__58]:
                self.enterOuterAlt(localctx, 5)
                self.state = 490
                self.coverageDeclaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ActorNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_actorName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterActorName"):
                listener.enterActorName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitActorName"):
                listener.exitActorName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActorName"):
                return visitor.visitActorName(self)
            else:
                return visitor.visitChildren(self)

    def actorName(self):
        localctx = OpenSCENARIO2Parser.ActorNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_actorName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 493
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ScenarioDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedBehaviorName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.QualifiedBehaviorNameContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def scenarioInherts(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ScenarioInhertsContext, 0
            )

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def scenarioMemberDecl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.ScenarioMemberDeclContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ScenarioMemberDeclContext, i
                )

        def behaviorSpecification(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.BehaviorSpecificationContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.BehaviorSpecificationContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_scenarioDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterScenarioDeclaration"):
                listener.enterScenarioDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitScenarioDeclaration"):
                listener.exitScenarioDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitScenarioDeclaration"):
                return visitor.visitScenarioDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def scenarioDeclaration(self):
        localctx = OpenSCENARIO2Parser.ScenarioDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 66, self.RULE_scenarioDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 495
            self.match(OpenSCENARIO2Parser.T__16)
            self.state = 496
            self.qualifiedBehaviorName()
            self.state = 498
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__14:
                self.state = 497
                self.scenarioInherts()

            self.state = 512
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__8]:
                self.state = 500
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 501
                self.match(OpenSCENARIO2Parser.NEWLINE)
                self.state = 502
                self.match(OpenSCENARIO2Parser.INDENT)
                self.state = 505
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 505
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [
                        OpenSCENARIO2Parser.T__27,
                        OpenSCENARIO2Parser.T__35,
                        OpenSCENARIO2Parser.T__38,
                        OpenSCENARIO2Parser.T__41,
                        OpenSCENARIO2Parser.T__51,
                        OpenSCENARIO2Parser.T__57,
                        OpenSCENARIO2Parser.T__58,
                        OpenSCENARIO2Parser.Identifier,
                    ]:
                        self.state = 503
                        self.scenarioMemberDecl()
                        pass
                    elif token in [
                        OpenSCENARIO2Parser.T__42,
                        OpenSCENARIO2Parser.T__43,
                    ]:
                        self.state = 504
                        self.behaviorSpecification()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 507
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << OpenSCENARIO2Parser.T__27)
                                    | (1 << OpenSCENARIO2Parser.T__35)
                                    | (1 << OpenSCENARIO2Parser.T__38)
                                    | (1 << OpenSCENARIO2Parser.T__41)
                                    | (1 << OpenSCENARIO2Parser.T__42)
                                    | (1 << OpenSCENARIO2Parser.T__43)
                                    | (1 << OpenSCENARIO2Parser.T__51)
                                    | (1 << OpenSCENARIO2Parser.T__57)
                                    | (1 << OpenSCENARIO2Parser.T__58)
                                )
                            )
                            != 0
                        )
                        or _la == OpenSCENARIO2Parser.Identifier
                    ):
                        break

                self.state = 509
                self.match(OpenSCENARIO2Parser.DEDENT)
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.state = 511
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ScenarioInhertsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedBehaviorName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.QualifiedBehaviorNameContext, 0
            )

        def inheritsCondition(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.InheritsConditionContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_scenarioInherts

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterScenarioInherts"):
                listener.enterScenarioInherts(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitScenarioInherts"):
                listener.exitScenarioInherts(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitScenarioInherts"):
                return visitor.visitScenarioInherts(self)
            else:
                return visitor.visitChildren(self)

    def scenarioInherts(self):
        localctx = OpenSCENARIO2Parser.ScenarioInhertsContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 68, self.RULE_scenarioInherts)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 514
            self.match(OpenSCENARIO2Parser.T__14)
            self.state = 515
            self.qualifiedBehaviorName()
            self.state = 517
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.OPEN_PAREN:
                self.state = 516
                self.inheritsCondition()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ScenarioMemberDeclContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventDeclarationContext, 0
            )

        def fieldDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.FieldDeclarationContext, 0
            )

        def constraintDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ConstraintDeclarationContext, 0
            )

        def methodDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.MethodDeclarationContext, 0
            )

        def coverageDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.CoverageDeclarationContext, 0
            )

        def modifierInvocation(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ModifierInvocationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_scenarioMemberDecl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterScenarioMemberDecl"):
                listener.enterScenarioMemberDecl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitScenarioMemberDecl"):
                listener.exitScenarioMemberDecl(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitScenarioMemberDecl"):
                return visitor.visitScenarioMemberDecl(self)
            else:
                return visitor.visitChildren(self)

    def scenarioMemberDecl(self):
        localctx = OpenSCENARIO2Parser.ScenarioMemberDeclContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 70, self.RULE_scenarioMemberDecl)
        try:
            self.state = 525
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 29, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 519
                self.eventDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 520
                self.fieldDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 521
                self.constraintDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 522
                self.methodDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 523
                self.coverageDeclaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 524
                self.modifierInvocation()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class QualifiedBehaviorNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def behaviorName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.BehaviorNameContext, 0)

        def actorName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ActorNameContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_qualifiedBehaviorName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterQualifiedBehaviorName"):
                listener.enterQualifiedBehaviorName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitQualifiedBehaviorName"):
                listener.exitQualifiedBehaviorName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitQualifiedBehaviorName"):
                return visitor.visitQualifiedBehaviorName(self)
            else:
                return visitor.visitChildren(self)

    def qualifiedBehaviorName(self):
        localctx = OpenSCENARIO2Parser.QualifiedBehaviorNameContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 72, self.RULE_qualifiedBehaviorName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 530
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 30, self._ctx)
            if la_ == 1:
                self.state = 527
                self.actorName()
                self.state = 528
                self.match(OpenSCENARIO2Parser.T__1)

            self.state = 532
            self.behaviorName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BehaviorNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_behaviorName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBehaviorName"):
                listener.enterBehaviorName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBehaviorName"):
                listener.exitBehaviorName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBehaviorName"):
                return visitor.visitBehaviorName(self)
            else:
                return visitor.visitChildren(self)

    def behaviorName(self):
        localctx = OpenSCENARIO2Parser.BehaviorNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_behaviorName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 534
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ActionDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedBehaviorName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.QualifiedBehaviorNameContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def actionInherts(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ActionInhertsContext, 0)

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def scenarioMemberDecl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.ScenarioMemberDeclContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ScenarioMemberDeclContext, i
                )

        def behaviorSpecification(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.BehaviorSpecificationContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.BehaviorSpecificationContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_actionDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterActionDeclaration"):
                listener.enterActionDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitActionDeclaration"):
                listener.exitActionDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActionDeclaration"):
                return visitor.visitActionDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def actionDeclaration(self):
        localctx = OpenSCENARIO2Parser.ActionDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 76, self.RULE_actionDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 536
            self.match(OpenSCENARIO2Parser.T__17)
            self.state = 537
            self.qualifiedBehaviorName()
            self.state = 539
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__14:
                self.state = 538
                self.actionInherts()

            self.state = 553
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__8]:
                self.state = 541
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 542
                self.match(OpenSCENARIO2Parser.NEWLINE)
                self.state = 543
                self.match(OpenSCENARIO2Parser.INDENT)
                self.state = 546
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 546
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [
                        OpenSCENARIO2Parser.T__27,
                        OpenSCENARIO2Parser.T__35,
                        OpenSCENARIO2Parser.T__38,
                        OpenSCENARIO2Parser.T__41,
                        OpenSCENARIO2Parser.T__51,
                        OpenSCENARIO2Parser.T__57,
                        OpenSCENARIO2Parser.T__58,
                        OpenSCENARIO2Parser.Identifier,
                    ]:
                        self.state = 544
                        self.scenarioMemberDecl()
                        pass
                    elif token in [
                        OpenSCENARIO2Parser.T__42,
                        OpenSCENARIO2Parser.T__43,
                    ]:
                        self.state = 545
                        self.behaviorSpecification()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 548
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << OpenSCENARIO2Parser.T__27)
                                    | (1 << OpenSCENARIO2Parser.T__35)
                                    | (1 << OpenSCENARIO2Parser.T__38)
                                    | (1 << OpenSCENARIO2Parser.T__41)
                                    | (1 << OpenSCENARIO2Parser.T__42)
                                    | (1 << OpenSCENARIO2Parser.T__43)
                                    | (1 << OpenSCENARIO2Parser.T__51)
                                    | (1 << OpenSCENARIO2Parser.T__57)
                                    | (1 << OpenSCENARIO2Parser.T__58)
                                )
                            )
                            != 0
                        )
                        or _la == OpenSCENARIO2Parser.Identifier
                    ):
                        break

                self.state = 550
                self.match(OpenSCENARIO2Parser.DEDENT)
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.state = 552
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ActionInhertsContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedBehaviorName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.QualifiedBehaviorNameContext, 0
            )

        def inheritsCondition(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.InheritsConditionContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_actionInherts

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterActionInherts"):
                listener.enterActionInherts(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitActionInherts"):
                listener.exitActionInherts(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActionInherts"):
                return visitor.visitActionInherts(self)
            else:
                return visitor.visitChildren(self)

    def actionInherts(self):
        localctx = OpenSCENARIO2Parser.ActionInhertsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_actionInherts)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 555
            self.match(OpenSCENARIO2Parser.T__14)
            self.state = 556
            self.qualifiedBehaviorName()
            self.state = 558
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.OPEN_PAREN:
                self.state = 557
                self.inheritsCondition()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ModifierDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def modifierName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ModifierNameContext, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def actorName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ActorNameContext, 0)

        def qualifiedBehaviorName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.QualifiedBehaviorNameContext, 0
            )

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def scenarioMemberDecl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.ScenarioMemberDeclContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ScenarioMemberDeclContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_modifierDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterModifierDeclaration"):
                listener.enterModifierDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitModifierDeclaration"):
                listener.exitModifierDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitModifierDeclaration"):
                return visitor.visitModifierDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def modifierDeclaration(self):
        localctx = OpenSCENARIO2Parser.ModifierDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 80, self.RULE_modifierDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 560
            self.match(OpenSCENARIO2Parser.T__18)
            self.state = 564
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 36, self._ctx)
            if la_ == 1:
                self.state = 561
                self.actorName()
                self.state = 562
                self.match(OpenSCENARIO2Parser.T__1)

            self.state = 566
            self.modifierName()
            self.state = 569
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__6:
                self.state = 567
                self.match(OpenSCENARIO2Parser.T__6)
                self.state = 568
                self.qualifiedBehaviorName()

            self.state = 582
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__8]:
                self.state = 571
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 572
                self.match(OpenSCENARIO2Parser.NEWLINE)
                self.state = 573
                self.match(OpenSCENARIO2Parser.INDENT)
                self.state = 575
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 574
                    self.scenarioMemberDecl()
                    self.state = 577
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (
                        (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << OpenSCENARIO2Parser.T__27)
                                    | (1 << OpenSCENARIO2Parser.T__35)
                                    | (1 << OpenSCENARIO2Parser.T__38)
                                    | (1 << OpenSCENARIO2Parser.T__41)
                                    | (1 << OpenSCENARIO2Parser.T__51)
                                    | (1 << OpenSCENARIO2Parser.T__57)
                                    | (1 << OpenSCENARIO2Parser.T__58)
                                )
                            )
                            != 0
                        )
                        or _la == OpenSCENARIO2Parser.Identifier
                    ):
                        break

                self.state = 579
                self.match(OpenSCENARIO2Parser.DEDENT)
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.state = 581
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ModifierNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_modifierName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterModifierName"):
                listener.enterModifierName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitModifierName"):
                listener.exitModifierName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitModifierName"):
                return visitor.visitModifierName(self)
            else:
                return visitor.visitChildren(self)

    def modifierName(self):
        localctx = OpenSCENARIO2Parser.ModifierNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_modifierName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 584
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeExtensionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumTypeExtension(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EnumTypeExtensionContext, 0
            )

        def structuredTypeExtension(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.StructuredTypeExtensionContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_typeExtension

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeExtension"):
                listener.enterTypeExtension(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeExtension"):
                listener.exitTypeExtension(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeExtension"):
                return visitor.visitTypeExtension(self)
            else:
                return visitor.visitChildren(self)

    def typeExtension(self):
        localctx = OpenSCENARIO2Parser.TypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_typeExtension)
        try:
            self.state = 588
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 40, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 586
                self.enumTypeExtension()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 587
                self.structuredTypeExtension()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumTypeExtensionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EnumNameContext, 0)

        def OPEN_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_BRACK, 0)

        def enumMemberDecl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.EnumMemberDeclContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.EnumMemberDeclContext, i
                )

        def CLOSE_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_BRACK, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_enumTypeExtension

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumTypeExtension"):
                listener.enterEnumTypeExtension(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumTypeExtension"):
                listener.exitEnumTypeExtension(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumTypeExtension"):
                return visitor.visitEnumTypeExtension(self)
            else:
                return visitor.visitChildren(self)

    def enumTypeExtension(self):
        localctx = OpenSCENARIO2Parser.EnumTypeExtensionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 86, self.RULE_enumTypeExtension)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 590
            self.match(OpenSCENARIO2Parser.T__19)
            self.state = 591
            self.enumName()
            self.state = 592
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 593
            self.match(OpenSCENARIO2Parser.OPEN_BRACK)
            self.state = 594
            self.enumMemberDecl()
            self.state = 599
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 595
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 596
                self.enumMemberDecl()
                self.state = 601
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 602
            self.match(OpenSCENARIO2Parser.CLOSE_BRACK)
            self.state = 603
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StructuredTypeExtensionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def extendableTypeName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ExtendableTypeNameContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def extensionMemberDecl(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.ExtensionMemberDeclContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ExtensionMemberDeclContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_structuredTypeExtension

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterStructuredTypeExtension"):
                listener.enterStructuredTypeExtension(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitStructuredTypeExtension"):
                listener.exitStructuredTypeExtension(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStructuredTypeExtension"):
                return visitor.visitStructuredTypeExtension(self)
            else:
                return visitor.visitChildren(self)

    def structuredTypeExtension(self):
        localctx = OpenSCENARIO2Parser.StructuredTypeExtensionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 88, self.RULE_structuredTypeExtension)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 605
            self.match(OpenSCENARIO2Parser.T__19)
            self.state = 606
            self.extendableTypeName()
            self.state = 607
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 608
            self.match(OpenSCENARIO2Parser.NEWLINE)
            self.state = 609
            self.match(OpenSCENARIO2Parser.INDENT)
            self.state = 611
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 610
                self.extensionMemberDecl()
                self.state = 613
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        ((_la) & ~0x3F) == 0
                        and (
                            (1 << _la)
                            & (
                                (1 << OpenSCENARIO2Parser.T__27)
                                | (1 << OpenSCENARIO2Parser.T__35)
                                | (1 << OpenSCENARIO2Parser.T__38)
                                | (1 << OpenSCENARIO2Parser.T__41)
                                | (1 << OpenSCENARIO2Parser.T__42)
                                | (1 << OpenSCENARIO2Parser.T__43)
                                | (1 << OpenSCENARIO2Parser.T__51)
                                | (1 << OpenSCENARIO2Parser.T__57)
                                | (1 << OpenSCENARIO2Parser.T__58)
                            )
                        )
                        != 0
                    )
                    or _la == OpenSCENARIO2Parser.Identifier
                ):
                    break

            self.state = 615
            self.match(OpenSCENARIO2Parser.DEDENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExtendableTypeNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TypeNameContext, 0)

        def qualifiedBehaviorName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.QualifiedBehaviorNameContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_extendableTypeName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterExtendableTypeName"):
                listener.enterExtendableTypeName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitExtendableTypeName"):
                listener.exitExtendableTypeName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExtendableTypeName"):
                return visitor.visitExtendableTypeName(self)
            else:
                return visitor.visitChildren(self)

    def extendableTypeName(self):
        localctx = OpenSCENARIO2Parser.ExtendableTypeNameContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 90, self.RULE_extendableTypeName)
        try:
            self.state = 619
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 43, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 617
                self.typeName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 618
                self.qualifiedBehaviorName()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExtensionMemberDeclContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def structMemberDecl(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.StructMemberDeclContext, 0
            )

        def actorMemberDecl(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ActorMemberDeclContext, 0
            )

        def scenarioMemberDecl(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ScenarioMemberDeclContext, 0
            )

        def behaviorSpecification(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BehaviorSpecificationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_extensionMemberDecl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterExtensionMemberDecl"):
                listener.enterExtensionMemberDecl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitExtensionMemberDecl"):
                listener.exitExtensionMemberDecl(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExtensionMemberDecl"):
                return visitor.visitExtensionMemberDecl(self)
            else:
                return visitor.visitChildren(self)

    def extensionMemberDecl(self):
        localctx = OpenSCENARIO2Parser.ExtensionMemberDeclContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 92, self.RULE_extensionMemberDecl)
        try:
            self.state = 625
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 44, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 621
                self.structMemberDecl()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 622
                self.actorMemberDecl()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 623
                self.scenarioMemberDecl()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 624
                self.behaviorSpecification()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class GlobalParameterDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fieldName(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.FieldNameContext)
            else:
                return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldNameContext, i)

        def typeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.TypeDeclaratorContext, 0
            )

        def parameterWithDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ParameterWithDeclarationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def defaultValue(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.DefaultValueContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_globalParameterDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGlobalParameterDeclaration"):
                listener.enterGlobalParameterDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGlobalParameterDeclaration"):
                listener.exitGlobalParameterDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitGlobalParameterDeclaration"):
                return visitor.visitGlobalParameterDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def globalParameterDeclaration(self):
        localctx = OpenSCENARIO2Parser.GlobalParameterDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 94, self.RULE_globalParameterDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 627
            self.match(OpenSCENARIO2Parser.T__20)
            self.state = 628
            self.fieldName()
            self.state = 633
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 629
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 630
                self.fieldName()
                self.state = 635
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 636
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 637
            self.typeDeclarator()
            self.state = 640
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__10:
                self.state = 638
                self.match(OpenSCENARIO2Parser.T__10)
                self.state = 639
                self.defaultValue()

            self.state = 644
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__37]:
                self.state = 642
                self.parameterWithDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.state = 643
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeDeclaratorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nonAggregateTypeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.NonAggregateTypeDeclaratorContext, 0
            )

        def aggregateTypeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.AggregateTypeDeclaratorContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_typeDeclarator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeDeclarator"):
                listener.enterTypeDeclarator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeDeclarator"):
                listener.exitTypeDeclarator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeDeclarator"):
                return visitor.visitTypeDeclarator(self)
            else:
                return visitor.visitChildren(self)

    def typeDeclarator(self):
        localctx = OpenSCENARIO2Parser.TypeDeclaratorContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 96, self.RULE_typeDeclarator)
        try:
            self.state = 648
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                OpenSCENARIO2Parser.T__22,
                OpenSCENARIO2Parser.T__23,
                OpenSCENARIO2Parser.T__24,
                OpenSCENARIO2Parser.T__25,
                OpenSCENARIO2Parser.T__26,
                OpenSCENARIO2Parser.Identifier,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 646
                self.nonAggregateTypeDeclarator()
                pass
            elif token in [OpenSCENARIO2Parser.T__21]:
                self.enterOuterAlt(localctx, 2)
                self.state = 647
                self.aggregateTypeDeclarator()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class NonAggregateTypeDeclaratorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def primitiveType(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PrimitiveTypeContext, 0)

        def typeName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TypeNameContext, 0)

        def qualifiedBehaviorName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.QualifiedBehaviorNameContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_nonAggregateTypeDeclarator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterNonAggregateTypeDeclarator"):
                listener.enterNonAggregateTypeDeclarator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitNonAggregateTypeDeclarator"):
                listener.exitNonAggregateTypeDeclarator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitNonAggregateTypeDeclarator"):
                return visitor.visitNonAggregateTypeDeclarator(self)
            else:
                return visitor.visitChildren(self)

    def nonAggregateTypeDeclarator(self):
        localctx = OpenSCENARIO2Parser.NonAggregateTypeDeclaratorContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 98, self.RULE_nonAggregateTypeDeclarator)
        try:
            self.state = 653
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 49, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 650
                self.primitiveType()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 651
                self.typeName()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 652
                self.qualifiedBehaviorName()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AggregateTypeDeclaratorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def listTypeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ListTypeDeclaratorContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_aggregateTypeDeclarator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAggregateTypeDeclarator"):
                listener.enterAggregateTypeDeclarator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAggregateTypeDeclarator"):
                listener.exitAggregateTypeDeclarator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAggregateTypeDeclarator"):
                return visitor.visitAggregateTypeDeclarator(self)
            else:
                return visitor.visitChildren(self)

    def aggregateTypeDeclarator(self):
        localctx = OpenSCENARIO2Parser.AggregateTypeDeclaratorContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 100, self.RULE_aggregateTypeDeclarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 655
            self.listTypeDeclarator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ListTypeDeclaratorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nonAggregateTypeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.NonAggregateTypeDeclaratorContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_listTypeDeclarator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterListTypeDeclarator"):
                listener.enterListTypeDeclarator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitListTypeDeclarator"):
                listener.exitListTypeDeclarator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitListTypeDeclarator"):
                return visitor.visitListTypeDeclarator(self)
            else:
                return visitor.visitChildren(self)

    def listTypeDeclarator(self):
        localctx = OpenSCENARIO2Parser.ListTypeDeclaratorContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 102, self.RULE_listTypeDeclarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 657
            self.match(OpenSCENARIO2Parser.T__21)
            self.state = 658
            self.match(OpenSCENARIO2Parser.T__6)
            self.state = 659
            self.nonAggregateTypeDeclarator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PrimitiveTypeContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_primitiveType

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPrimitiveType"):
                listener.enterPrimitiveType(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPrimitiveType"):
                listener.exitPrimitiveType(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPrimitiveType"):
                return visitor.visitPrimitiveType(self)
            else:
                return visitor.visitChildren(self)

    def primitiveType(self):
        localctx = OpenSCENARIO2Parser.PrimitiveTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_primitiveType)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 661
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << OpenSCENARIO2Parser.T__22)
                            | (1 << OpenSCENARIO2Parser.T__23)
                            | (1 << OpenSCENARIO2Parser.T__24)
                            | (1 << OpenSCENARIO2Parser.T__25)
                            | (1 << OpenSCENARIO2Parser.T__26)
                        )
                    )
                    != 0
                )
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_typeName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeName"):
                listener.enterTypeName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeName"):
                listener.exitTypeName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeName"):
                return visitor.visitTypeName(self)
            else:
                return visitor.visitChildren(self)

    def typeName(self):
        localctx = OpenSCENARIO2Parser.TypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_typeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 663
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EventDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EventNameContext, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def argumentListSpecification(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ArgumentListSpecificationContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def eventSpecification(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventSpecificationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_eventDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEventDeclaration"):
                listener.enterEventDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEventDeclaration"):
                listener.exitEventDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEventDeclaration"):
                return visitor.visitEventDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def eventDeclaration(self):
        localctx = OpenSCENARIO2Parser.EventDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 108, self.RULE_eventDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.match(OpenSCENARIO2Parser.T__27)
            self.state = 666
            self.eventName()
            self.state = 671
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.OPEN_PAREN:
                self.state = 667
                self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                self.state = 668
                self.argumentListSpecification()
                self.state = 669
                self.match(OpenSCENARIO2Parser.CLOSE_PAREN)

            self.state = 675
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__3:
                self.state = 673
                self.match(OpenSCENARIO2Parser.T__3)
                self.state = 674
                self.eventSpecification()

            self.state = 677
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EventSpecificationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventReference(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventReferenceContext, 0
            )

        def eventCondition(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventConditionContext, 0
            )

        def eventFieldDecl(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventFieldDeclContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_eventSpecification

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEventSpecification"):
                listener.enterEventSpecification(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEventSpecification"):
                listener.exitEventSpecification(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEventSpecification"):
                return visitor.visitEventSpecification(self)
            else:
                return visitor.visitChildren(self)

    def eventSpecification(self):
        localctx = OpenSCENARIO2Parser.EventSpecificationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 110, self.RULE_eventSpecification)
        self._la = 0  # Token type
        try:
            self.state = 688
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__29]:
                self.enterOuterAlt(localctx, 1)
                self.state = 679
                self.eventReference()
                self.state = 685
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == OpenSCENARIO2Parser.T__28 or _la == OpenSCENARIO2Parser.T__30:
                    self.state = 681
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la == OpenSCENARIO2Parser.T__30:
                        self.state = 680
                        self.eventFieldDecl()

                    self.state = 683
                    self.match(OpenSCENARIO2Parser.T__28)
                    self.state = 684
                    self.eventCondition()

                pass
            elif token in [
                OpenSCENARIO2Parser.T__31,
                OpenSCENARIO2Parser.T__32,
                OpenSCENARIO2Parser.T__33,
                OpenSCENARIO2Parser.T__34,
                OpenSCENARIO2Parser.T__59,
                OpenSCENARIO2Parser.T__64,
                OpenSCENARIO2Parser.T__72,
                OpenSCENARIO2Parser.T__76,
                OpenSCENARIO2Parser.OPEN_BRACK,
                OpenSCENARIO2Parser.OPEN_PAREN,
                OpenSCENARIO2Parser.StringLiteral,
                OpenSCENARIO2Parser.FloatLiteral,
                OpenSCENARIO2Parser.UintLiteral,
                OpenSCENARIO2Parser.HexUintLiteral,
                OpenSCENARIO2Parser.IntLiteral,
                OpenSCENARIO2Parser.BoolLiteral,
                OpenSCENARIO2Parser.Identifier,
            ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 687
                self.eventCondition()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EventReferenceContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventPath(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EventPathContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_eventReference

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEventReference"):
                listener.enterEventReference(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEventReference"):
                listener.exitEventReference(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEventReference"):
                return visitor.visitEventReference(self)
            else:
                return visitor.visitChildren(self)

    def eventReference(self):
        localctx = OpenSCENARIO2Parser.EventReferenceContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 112, self.RULE_eventReference)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 690
            self.match(OpenSCENARIO2Parser.T__29)
            self.state = 691
            self.eventPath()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EventFieldDeclContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventFieldName(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventFieldNameContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_eventFieldDecl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEventFieldDecl"):
                listener.enterEventFieldDecl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEventFieldDecl"):
                listener.exitEventFieldDecl(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEventFieldDecl"):
                return visitor.visitEventFieldDecl(self)
            else:
                return visitor.visitChildren(self)

    def eventFieldDecl(self):
        localctx = OpenSCENARIO2Parser.EventFieldDeclContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 114, self.RULE_eventFieldDecl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 693
            self.match(OpenSCENARIO2Parser.T__30)
            self.state = 694
            self.eventFieldName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EventFieldNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_eventFieldName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEventFieldName"):
                listener.enterEventFieldName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEventFieldName"):
                listener.exitEventFieldName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEventFieldName"):
                return visitor.visitEventFieldName(self)
            else:
                return visitor.visitChildren(self)

    def eventFieldName(self):
        localctx = OpenSCENARIO2Parser.EventFieldNameContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 116, self.RULE_eventFieldName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 696
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EventNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_eventName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEventName"):
                listener.enterEventName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEventName"):
                listener.exitEventName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEventName"):
                return visitor.visitEventName(self)
            else:
                return visitor.visitChildren(self)

    def eventName(self):
        localctx = OpenSCENARIO2Parser.EventNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_eventName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 698
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EventPathContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EventNameContext, 0)

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_eventPath

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEventPath"):
                listener.enterEventPath(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEventPath"):
                listener.exitEventPath(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEventPath"):
                return visitor.visitEventPath(self)
            else:
                return visitor.visitChildren(self)

    def eventPath(self):
        localctx = OpenSCENARIO2Parser.EventPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_eventPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 703
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 55, self._ctx)
            if la_ == 1:
                self.state = 700
                self.expression()
                self.state = 701
                self.match(OpenSCENARIO2Parser.T__1)

            self.state = 705
            self.eventName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EventConditionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def boolExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BoolExpressionContext, 0
            )

        def riseExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.RiseExpressionContext, 0
            )

        def fallExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.FallExpressionContext, 0
            )

        def elapsedExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ElapsedExpressionContext, 0
            )

        def everyExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EveryExpressionContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_eventCondition

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEventCondition"):
                listener.enterEventCondition(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEventCondition"):
                listener.exitEventCondition(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEventCondition"):
                return visitor.visitEventCondition(self)
            else:
                return visitor.visitChildren(self)

    def eventCondition(self):
        localctx = OpenSCENARIO2Parser.EventConditionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 122, self.RULE_eventCondition)
        try:
            self.state = 712
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                OpenSCENARIO2Parser.T__59,
                OpenSCENARIO2Parser.T__64,
                OpenSCENARIO2Parser.T__72,
                OpenSCENARIO2Parser.T__76,
                OpenSCENARIO2Parser.OPEN_BRACK,
                OpenSCENARIO2Parser.OPEN_PAREN,
                OpenSCENARIO2Parser.StringLiteral,
                OpenSCENARIO2Parser.FloatLiteral,
                OpenSCENARIO2Parser.UintLiteral,
                OpenSCENARIO2Parser.HexUintLiteral,
                OpenSCENARIO2Parser.IntLiteral,
                OpenSCENARIO2Parser.BoolLiteral,
                OpenSCENARIO2Parser.Identifier,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 707
                self.boolExpression()
                pass
            elif token in [OpenSCENARIO2Parser.T__31]:
                self.enterOuterAlt(localctx, 2)
                self.state = 708
                self.riseExpression()
                pass
            elif token in [OpenSCENARIO2Parser.T__32]:
                self.enterOuterAlt(localctx, 3)
                self.state = 709
                self.fallExpression()
                pass
            elif token in [OpenSCENARIO2Parser.T__33]:
                self.enterOuterAlt(localctx, 4)
                self.state = 710
                self.elapsedExpression()
                pass
            elif token in [OpenSCENARIO2Parser.T__34]:
                self.enterOuterAlt(localctx, 5)
                self.state = 711
                self.everyExpression()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class RiseExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def boolExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BoolExpressionContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_riseExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterRiseExpression"):
                listener.enterRiseExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitRiseExpression"):
                listener.exitRiseExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitRiseExpression"):
                return visitor.visitRiseExpression(self)
            else:
                return visitor.visitChildren(self)

    def riseExpression(self):
        localctx = OpenSCENARIO2Parser.RiseExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 124, self.RULE_riseExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 714
            self.match(OpenSCENARIO2Parser.T__31)
            self.state = 715
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 716
            self.boolExpression()
            self.state = 717
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FallExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def boolExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BoolExpressionContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_fallExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFallExpression"):
                listener.enterFallExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFallExpression"):
                listener.exitFallExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFallExpression"):
                return visitor.visitFallExpression(self)
            else:
                return visitor.visitChildren(self)

    def fallExpression(self):
        localctx = OpenSCENARIO2Parser.FallExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 126, self.RULE_fallExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 719
            self.match(OpenSCENARIO2Parser.T__32)
            self.state = 720
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 721
            self.boolExpression()
            self.state = 722
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ElapsedExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def durationExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.DurationExpressionContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_elapsedExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterElapsedExpression"):
                listener.enterElapsedExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitElapsedExpression"):
                listener.exitElapsedExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitElapsedExpression"):
                return visitor.visitElapsedExpression(self)
            else:
                return visitor.visitChildren(self)

    def elapsedExpression(self):
        localctx = OpenSCENARIO2Parser.ElapsedExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 128, self.RULE_elapsedExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 724
            self.match(OpenSCENARIO2Parser.T__33)
            self.state = 725
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 726
            self.durationExpression()
            self.state = 727
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EveryExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._Identifier = None  # Token

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def durationExpression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.DurationExpressionContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.DurationExpressionContext, i
                )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_everyExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEveryExpression"):
                listener.enterEveryExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEveryExpression"):
                listener.exitEveryExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEveryExpression"):
                return visitor.visitEveryExpression(self)
            else:
                return visitor.visitChildren(self)

    def everyExpression(self):
        localctx = OpenSCENARIO2Parser.EveryExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 130, self.RULE_everyExpression)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 729
            self.match(OpenSCENARIO2Parser.T__34)
            self.state = 730
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 731
            self.durationExpression()
            self.state = 737
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__7:
                self.state = 732
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 733
                localctx._Identifier = self.match(OpenSCENARIO2Parser.Identifier)

                offsetName = (
                    None if localctx._Identifier is None else localctx._Identifier.text
                )
                if not (offsetName == "offset"):
                    print("%s must be offset" % offsetName)
                    raise NoViableAltException(self)

                self.state = 735
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 736
                self.durationExpression()

            self.state = 739
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BoolExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_boolExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBoolExpression"):
                listener.enterBoolExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBoolExpression"):
                listener.exitBoolExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBoolExpression"):
                return visitor.visitBoolExpression(self)
            else:
                return visitor.visitChildren(self)

    def boolExpression(self):
        localctx = OpenSCENARIO2Parser.BoolExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 132, self.RULE_boolExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 741
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DurationExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_durationExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterDurationExpression"):
                listener.enterDurationExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitDurationExpression"):
                listener.exitDurationExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitDurationExpression"):
                return visitor.visitDurationExpression(self)
            else:
                return visitor.visitChildren(self)

    def durationExpression(self):
        localctx = OpenSCENARIO2Parser.DurationExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 134, self.RULE_durationExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 743
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FieldDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ParameterDeclarationContext, 0
            )

        def variableDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.VariableDeclarationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_fieldDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFieldDeclaration"):
                listener.enterFieldDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFieldDeclaration"):
                listener.exitFieldDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFieldDeclaration"):
                return visitor.visitFieldDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def fieldDeclaration(self):
        localctx = OpenSCENARIO2Parser.FieldDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 136, self.RULE_fieldDeclaration)
        try:
            self.state = 747
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 745
                self.parameterDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__35]:
                self.enterOuterAlt(localctx, 2)
                self.state = 746
                self.variableDeclaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ParameterDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fieldName(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.FieldNameContext)
            else:
                return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldNameContext, i)

        def typeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.TypeDeclaratorContext, 0
            )

        def parameterWithDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ParameterWithDeclarationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def defaultValue(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.DefaultValueContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_parameterDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterParameterDeclaration"):
                listener.enterParameterDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitParameterDeclaration"):
                listener.exitParameterDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParameterDeclaration"):
                return visitor.visitParameterDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def parameterDeclaration(self):
        localctx = OpenSCENARIO2Parser.ParameterDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 138, self.RULE_parameterDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 749
            self.fieldName()
            self.state = 754
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 750
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 751
                self.fieldName()
                self.state = 756
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 757
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 758
            self.typeDeclarator()
            self.state = 761
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__10:
                self.state = 759
                self.match(OpenSCENARIO2Parser.T__10)
                self.state = 760
                self.defaultValue()

            self.state = 765
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__37]:
                self.state = 763
                self.parameterWithDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.state = 764
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class VariableDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fieldName(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.FieldNameContext)
            else:
                return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldNameContext, i)

        def typeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.TypeDeclaratorContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def sampleExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.SampleExpressionContext, 0
            )

        def valueExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ValueExpContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_variableDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterVariableDeclaration"):
                listener.enterVariableDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitVariableDeclaration"):
                listener.exitVariableDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitVariableDeclaration"):
                return visitor.visitVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def variableDeclaration(self):
        localctx = OpenSCENARIO2Parser.VariableDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 140, self.RULE_variableDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 767
            self.match(OpenSCENARIO2Parser.T__35)
            self.state = 768
            self.fieldName()
            self.state = 773
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 769
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 770
                self.fieldName()
                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 776
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 777
            self.typeDeclarator()
            self.state = 783
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__10:
                self.state = 778
                self.match(OpenSCENARIO2Parser.T__10)
                self.state = 781
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [OpenSCENARIO2Parser.T__36]:
                    self.state = 779
                    self.sampleExpression()
                    pass
                elif token in [
                    OpenSCENARIO2Parser.T__59,
                    OpenSCENARIO2Parser.OPEN_BRACK,
                    OpenSCENARIO2Parser.StringLiteral,
                    OpenSCENARIO2Parser.FloatLiteral,
                    OpenSCENARIO2Parser.UintLiteral,
                    OpenSCENARIO2Parser.HexUintLiteral,
                    OpenSCENARIO2Parser.IntLiteral,
                    OpenSCENARIO2Parser.BoolLiteral,
                    OpenSCENARIO2Parser.Identifier,
                ]:
                    self.state = 780
                    self.valueExp()
                    pass
                else:
                    raise NoViableAltException(self)

            self.state = 785
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SampleExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def eventSpecification(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventSpecificationContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def defaultValue(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.DefaultValueContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_sampleExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSampleExpression"):
                listener.enterSampleExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSampleExpression"):
                listener.exitSampleExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSampleExpression"):
                return visitor.visitSampleExpression(self)
            else:
                return visitor.visitChildren(self)

    def sampleExpression(self):
        localctx = OpenSCENARIO2Parser.SampleExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 142, self.RULE_sampleExpression)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 787
            self.match(OpenSCENARIO2Parser.T__36)
            self.state = 788
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 789
            self.expression()
            self.state = 790
            self.match(OpenSCENARIO2Parser.T__7)
            self.state = 791
            self.eventSpecification()
            self.state = 794
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__7:
                self.state = 792
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 793
                self.defaultValue()

            self.state = 796
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DefaultValueContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_defaultValue

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterDefaultValue"):
                listener.enterDefaultValue(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitDefaultValue"):
                listener.exitDefaultValue(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitDefaultValue"):
                return visitor.visitDefaultValue(self)
            else:
                return visitor.visitChildren(self)

    def defaultValue(self):
        localctx = OpenSCENARIO2Parser.DefaultValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_defaultValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 798
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ParameterWithDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def parameterWithMember(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.ParameterWithMemberContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ParameterWithMemberContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_parameterWithDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterParameterWithDeclaration"):
                listener.enterParameterWithDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitParameterWithDeclaration"):
                listener.exitParameterWithDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParameterWithDeclaration"):
                return visitor.visitParameterWithDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def parameterWithDeclaration(self):
        localctx = OpenSCENARIO2Parser.ParameterWithDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 146, self.RULE_parameterWithDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 800
            self.match(OpenSCENARIO2Parser.T__37)
            self.state = 801
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 802
            self.match(OpenSCENARIO2Parser.NEWLINE)
            self.state = 803
            self.match(OpenSCENARIO2Parser.INDENT)
            self.state = 805
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 804
                self.parameterWithMember()
                self.state = 807
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        ((_la) & ~0x3F) == 0
                        and (
                            (1 << _la)
                            & (
                                (1 << OpenSCENARIO2Parser.T__38)
                                | (1 << OpenSCENARIO2Parser.T__41)
                                | (1 << OpenSCENARIO2Parser.T__57)
                                | (1 << OpenSCENARIO2Parser.T__58)
                            )
                        )
                        != 0
                    )
                ):
                    break

            self.state = 809
            self.match(OpenSCENARIO2Parser.DEDENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ParameterWithMemberContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constraintDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ConstraintDeclarationContext, 0
            )

        def coverageDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.CoverageDeclarationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_parameterWithMember

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterParameterWithMember"):
                listener.enterParameterWithMember(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitParameterWithMember"):
                listener.exitParameterWithMember(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParameterWithMember"):
                return visitor.visitParameterWithMember(self)
            else:
                return visitor.visitChildren(self)

    def parameterWithMember(self):
        localctx = OpenSCENARIO2Parser.ParameterWithMemberContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 148, self.RULE_parameterWithMember)
        try:
            self.state = 813
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__38, OpenSCENARIO2Parser.T__41]:
                self.enterOuterAlt(localctx, 1)
                self.state = 811
                self.constraintDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__57, OpenSCENARIO2Parser.T__58]:
                self.enterOuterAlt(localctx, 2)
                self.state = 812
                self.coverageDeclaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ConstraintDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def keepConstraintDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.KeepConstraintDeclarationContext, 0
            )

        def removeDefaultDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.RemoveDefaultDeclarationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_constraintDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterConstraintDeclaration"):
                listener.enterConstraintDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitConstraintDeclaration"):
                listener.exitConstraintDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitConstraintDeclaration"):
                return visitor.visitConstraintDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def constraintDeclaration(self):
        localctx = OpenSCENARIO2Parser.ConstraintDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 150, self.RULE_constraintDeclaration)
        try:
            self.state = 817
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__38]:
                self.enterOuterAlt(localctx, 1)
                self.state = 815
                self.keepConstraintDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__41]:
                self.enterOuterAlt(localctx, 2)
                self.state = 816
                self.removeDefaultDeclaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class KeepConstraintDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def constraintExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ConstraintExpressionContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def constraintQualifier(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ConstraintQualifierContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_keepConstraintDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterKeepConstraintDeclaration"):
                listener.enterKeepConstraintDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitKeepConstraintDeclaration"):
                listener.exitKeepConstraintDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitKeepConstraintDeclaration"):
                return visitor.visitKeepConstraintDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def keepConstraintDeclaration(self):
        localctx = OpenSCENARIO2Parser.KeepConstraintDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 152, self.RULE_keepConstraintDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 819
            self.match(OpenSCENARIO2Parser.T__38)
            self.state = 820
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 822
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__39 or _la == OpenSCENARIO2Parser.T__40:
                self.state = 821
                self.constraintQualifier()

            self.state = 824
            self.constraintExpression()
            self.state = 825
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
            self.state = 826
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ConstraintQualifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_constraintQualifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterConstraintQualifier"):
                listener.enterConstraintQualifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitConstraintQualifier"):
                listener.exitConstraintQualifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitConstraintQualifier"):
                return visitor.visitConstraintQualifier(self)
            else:
                return visitor.visitChildren(self)

    def constraintQualifier(self):
        localctx = OpenSCENARIO2Parser.ConstraintQualifierContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 154, self.RULE_constraintQualifier)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 828
            _la = self._input.LA(1)
            if not (
                _la == OpenSCENARIO2Parser.T__39 or _la == OpenSCENARIO2Parser.T__40
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ConstraintExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_constraintExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterConstraintExpression"):
                listener.enterConstraintExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitConstraintExpression"):
                listener.exitConstraintExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitConstraintExpression"):
                return visitor.visitConstraintExpression(self)
            else:
                return visitor.visitChildren(self)

    def constraintExpression(self):
        localctx = OpenSCENARIO2Parser.ConstraintExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 156, self.RULE_constraintExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 830
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class RemoveDefaultDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def parameterReference(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ParameterReferenceContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_removeDefaultDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterRemoveDefaultDeclaration"):
                listener.enterRemoveDefaultDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitRemoveDefaultDeclaration"):
                listener.exitRemoveDefaultDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitRemoveDefaultDeclaration"):
                return visitor.visitRemoveDefaultDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def removeDefaultDeclaration(self):
        localctx = OpenSCENARIO2Parser.RemoveDefaultDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 158, self.RULE_removeDefaultDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 832
            self.match(OpenSCENARIO2Parser.T__41)
            self.state = 833
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 834
            self.parameterReference()
            self.state = 835
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
            self.state = 836
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ParameterReferenceContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fieldName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldNameContext, 0)

        def fieldAccess(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldAccessContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_parameterReference

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterParameterReference"):
                listener.enterParameterReference(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitParameterReference"):
                listener.exitParameterReference(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParameterReference"):
                return visitor.visitParameterReference(self)
            else:
                return visitor.visitChildren(self)

    def parameterReference(self):
        localctx = OpenSCENARIO2Parser.ParameterReferenceContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 160, self.RULE_parameterReference)
        try:
            self.state = 840
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 70, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 838
                self.fieldName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 839
                self.fieldAccess()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ModifierInvocationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def modifierName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ModifierNameContext, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def argumentList(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentListContext, 0)

        def behaviorExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BehaviorExpressionContext, 0
            )

        def actorExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ActorExpressionContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_modifierInvocation

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterModifierInvocation"):
                listener.enterModifierInvocation(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitModifierInvocation"):
                listener.exitModifierInvocation(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitModifierInvocation"):
                return visitor.visitModifierInvocation(self)
            else:
                return visitor.visitChildren(self)

    def modifierInvocation(self):
        localctx = OpenSCENARIO2Parser.ModifierInvocationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 162, self.RULE_modifierInvocation)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 848
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 72, self._ctx)
            if la_ == 1:
                self.state = 844
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 71, self._ctx)
                if la_ == 1:
                    self.state = 842
                    self.behaviorExpression()
                    pass

                elif la_ == 2:
                    self.state = 843
                    self.actorExpression()
                    pass

                self.state = 846
                self.match(OpenSCENARIO2Parser.T__1)

            self.state = 850
            self.modifierName()
            self.state = 851
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 853
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 60)) & ~0x3F) == 0 and (
                (1 << (_la - 60))
                & (
                    (1 << (OpenSCENARIO2Parser.T__59 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__64 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__72 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__76 - 60))
                    | (1 << (OpenSCENARIO2Parser.OPEN_BRACK - 60))
                    | (1 << (OpenSCENARIO2Parser.OPEN_PAREN - 60))
                    | (1 << (OpenSCENARIO2Parser.StringLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.FloatLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.UintLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.HexUintLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.IntLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.BoolLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.Identifier - 60))
                )
            ) != 0:
                self.state = 852
                self.argumentList()

            self.state = 855
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
            self.state = 856
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BehaviorExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def behaviorName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.BehaviorNameContext, 0)

        def actorExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ActorExpressionContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_behaviorExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBehaviorExpression"):
                listener.enterBehaviorExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBehaviorExpression"):
                listener.exitBehaviorExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBehaviorExpression"):
                return visitor.visitBehaviorExpression(self)
            else:
                return visitor.visitChildren(self)

    def behaviorExpression(self):
        localctx = OpenSCENARIO2Parser.BehaviorExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 164, self.RULE_behaviorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 858
            self.actorExpression()
            self.state = 859
            self.match(OpenSCENARIO2Parser.T__1)
            self.state = 861
            self.behaviorName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BehaviorSpecificationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def onDirective(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.OnDirectiveContext, 0)

        def doDirective(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.DoDirectiveContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_behaviorSpecification

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBehaviorSpecification"):
                listener.enterBehaviorSpecification(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBehaviorSpecification"):
                listener.exitBehaviorSpecification(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBehaviorSpecification"):
                return visitor.visitBehaviorSpecification(self)
            else:
                return visitor.visitChildren(self)

    def behaviorSpecification(self):
        localctx = OpenSCENARIO2Parser.BehaviorSpecificationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 166, self.RULE_behaviorSpecification)
        try:
            self.state = 865
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__42]:
                self.enterOuterAlt(localctx, 1)
                self.state = 863
                self.onDirective()
                pass
            elif token in [OpenSCENARIO2Parser.T__43]:
                self.enterOuterAlt(localctx, 2)
                self.state = 864
                self.doDirective()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OnDirectiveContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventSpecification(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventSpecificationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def onMember(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.OnMemberContext)
            else:
                return self.getTypedRuleContext(OpenSCENARIO2Parser.OnMemberContext, i)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_onDirective

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterOnDirective"):
                listener.enterOnDirective(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitOnDirective"):
                listener.exitOnDirective(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitOnDirective"):
                return visitor.visitOnDirective(self)
            else:
                return visitor.visitChildren(self)

    def onDirective(self):
        localctx = OpenSCENARIO2Parser.OnDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_onDirective)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 867
            self.match(OpenSCENARIO2Parser.T__42)
            self.state = 868
            self.eventSpecification()
            self.state = 869
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 870
            self.match(OpenSCENARIO2Parser.NEWLINE)
            self.state = 871
            self.match(OpenSCENARIO2Parser.INDENT)
            self.state = 873
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 872
                self.onMember()
                self.state = 875
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    _la == OpenSCENARIO2Parser.T__48 or _la == OpenSCENARIO2Parser.T__49
                ):
                    break

            self.state = 877
            self.match(OpenSCENARIO2Parser.DEDENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class OnMemberContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def callDirective(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.CallDirectiveContext, 0)

        def emitDirective(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EmitDirectiveContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_onMember

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterOnMember"):
                listener.enterOnMember(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitOnMember"):
                listener.exitOnMember(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitOnMember"):
                return visitor.visitOnMember(self)
            else:
                return visitor.visitChildren(self)

    def onMember(self):
        localctx = OpenSCENARIO2Parser.OnMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_onMember)
        try:
            self.state = 881
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__49]:
                self.enterOuterAlt(localctx, 1)
                self.state = 879
                self.callDirective()
                pass
            elif token in [OpenSCENARIO2Parser.T__48]:
                self.enterOuterAlt(localctx, 2)
                self.state = 880
                self.emitDirective()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DoDirectiveContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def doMember(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.DoMemberContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_doDirective

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterDoDirective"):
                listener.enterDoDirective(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitDoDirective"):
                listener.exitDoDirective(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitDoDirective"):
                return visitor.visitDoDirective(self)
            else:
                return visitor.visitChildren(self)

    def doDirective(self):
        localctx = OpenSCENARIO2Parser.DoDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_doDirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 883
            self.match(OpenSCENARIO2Parser.T__43)
            self.state = 884
            self.doMember()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DoMemberContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def composition(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.CompositionContext, 0)

        def behaviorInvocation(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BehaviorInvocationContext, 0
            )

        def waitDirective(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.WaitDirectiveContext, 0)

        def emitDirective(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EmitDirectiveContext, 0)

        def callDirective(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.CallDirectiveContext, 0)

        def labelName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.LabelNameContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_doMember

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterDoMember"):
                listener.enterDoMember(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitDoMember"):
                listener.exitDoMember(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitDoMember"):
                return visitor.visitDoMember(self)
            else:
                return visitor.visitChildren(self)

    def doMember(self):
        localctx = OpenSCENARIO2Parser.DoMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_doMember)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 889
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 77, self._ctx)
            if la_ == 1:
                self.state = 886
                self.labelName()
                self.state = 887
                self.match(OpenSCENARIO2Parser.T__8)

            self.state = 896
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                OpenSCENARIO2Parser.T__44,
                OpenSCENARIO2Parser.T__45,
                OpenSCENARIO2Parser.T__46,
            ]:
                self.state = 891
                self.composition()
                pass
            elif token in [OpenSCENARIO2Parser.Identifier]:
                self.state = 892
                self.behaviorInvocation()
                pass
            elif token in [OpenSCENARIO2Parser.T__47]:
                self.state = 893
                self.waitDirective()
                pass
            elif token in [OpenSCENARIO2Parser.T__48]:
                self.state = 894
                self.emitDirective()
                pass
            elif token in [OpenSCENARIO2Parser.T__49]:
                self.state = 895
                self.callDirective()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CompositionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def compositionOperator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.CompositionOperatorContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def doMember(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.DoMemberContext)
            else:
                return self.getTypedRuleContext(OpenSCENARIO2Parser.DoMemberContext, i)

        def behaviorWithDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BehaviorWithDeclarationContext, 0
            )

        def argumentList(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentListContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_composition

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterComposition"):
                listener.enterComposition(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitComposition"):
                listener.exitComposition(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitComposition"):
                return visitor.visitComposition(self)
            else:
                return visitor.visitChildren(self)

    def composition(self):
        localctx = OpenSCENARIO2Parser.CompositionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_composition)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 898
            self.compositionOperator()
            self.state = 904
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.OPEN_PAREN:
                self.state = 899
                self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                self.state = 901
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 60)) & ~0x3F) == 0 and (
                    (1 << (_la - 60))
                    & (
                        (1 << (OpenSCENARIO2Parser.T__59 - 60))
                        | (1 << (OpenSCENARIO2Parser.T__64 - 60))
                        | (1 << (OpenSCENARIO2Parser.T__72 - 60))
                        | (1 << (OpenSCENARIO2Parser.T__76 - 60))
                        | (1 << (OpenSCENARIO2Parser.OPEN_BRACK - 60))
                        | (1 << (OpenSCENARIO2Parser.OPEN_PAREN - 60))
                        | (1 << (OpenSCENARIO2Parser.StringLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.FloatLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.UintLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.HexUintLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.IntLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.BoolLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.Identifier - 60))
                    )
                ) != 0:
                    self.state = 900
                    self.argumentList()

                self.state = 903
                self.match(OpenSCENARIO2Parser.CLOSE_PAREN)

            self.state = 906
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 907
            self.match(OpenSCENARIO2Parser.NEWLINE)
            self.state = 908
            self.match(OpenSCENARIO2Parser.INDENT)
            self.state = 910
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 909
                self.doMember()
                self.state = 912
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        (((_la - 45)) & ~0x3F) == 0
                        and (
                            (1 << (_la - 45))
                            & (
                                (1 << (OpenSCENARIO2Parser.T__44 - 45))
                                | (1 << (OpenSCENARIO2Parser.T__45 - 45))
                                | (1 << (OpenSCENARIO2Parser.T__46 - 45))
                                | (1 << (OpenSCENARIO2Parser.T__47 - 45))
                                | (1 << (OpenSCENARIO2Parser.T__48 - 45))
                                | (1 << (OpenSCENARIO2Parser.T__49 - 45))
                                | (1 << (OpenSCENARIO2Parser.Identifier - 45))
                            )
                        )
                        != 0
                    )
                ):
                    break

            self.state = 914
            self.match(OpenSCENARIO2Parser.DEDENT)
            self.state = 916
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__37:
                self.state = 915
                self.behaviorWithDeclaration()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CompositionOperatorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_compositionOperator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCompositionOperator"):
                listener.enterCompositionOperator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCompositionOperator"):
                listener.exitCompositionOperator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCompositionOperator"):
                return visitor.visitCompositionOperator(self)
            else:
                return visitor.visitChildren(self)

    def compositionOperator(self):
        localctx = OpenSCENARIO2Parser.CompositionOperatorContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 178, self.RULE_compositionOperator)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 918
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << OpenSCENARIO2Parser.T__44)
                            | (1 << OpenSCENARIO2Parser.T__45)
                            | (1 << OpenSCENARIO2Parser.T__46)
                        )
                    )
                    != 0
                )
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BehaviorInvocationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def behaviorName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.BehaviorNameContext, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def behaviorWithDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.BehaviorWithDeclarationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def actorExpression(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ActorExpressionContext, 0
            )

        def argumentList(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentListContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_behaviorInvocation

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBehaviorInvocation"):
                listener.enterBehaviorInvocation(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBehaviorInvocation"):
                listener.exitBehaviorInvocation(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBehaviorInvocation"):
                return visitor.visitBehaviorInvocation(self)
            else:
                return visitor.visitChildren(self)

    def behaviorInvocation(self):
        localctx = OpenSCENARIO2Parser.BehaviorInvocationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 180, self.RULE_behaviorInvocation)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 923
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 83, self._ctx)
            if la_ == 1:
                self.state = 920
                self.actorExpression()
                self.state = 921
                self.match(OpenSCENARIO2Parser.T__1)

            self.state = 925
            self.behaviorName()
            self.state = 926
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 928
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 60)) & ~0x3F) == 0 and (
                (1 << (_la - 60))
                & (
                    (1 << (OpenSCENARIO2Parser.T__59 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__64 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__72 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__76 - 60))
                    | (1 << (OpenSCENARIO2Parser.OPEN_BRACK - 60))
                    | (1 << (OpenSCENARIO2Parser.OPEN_PAREN - 60))
                    | (1 << (OpenSCENARIO2Parser.StringLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.FloatLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.UintLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.HexUintLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.IntLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.BoolLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.Identifier - 60))
                )
            ) != 0:
                self.state = 927
                self.argumentList()

            self.state = 930
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
            self.state = 933
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__37]:
                self.state = 931
                self.behaviorWithDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.NEWLINE]:
                self.state = 932
                self.match(OpenSCENARIO2Parser.NEWLINE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BehaviorWithDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def INDENT(self):
            return self.getToken(OpenSCENARIO2Parser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(OpenSCENARIO2Parser.DEDENT, 0)

        def behaviorWithMember(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.BehaviorWithMemberContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.BehaviorWithMemberContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_behaviorWithDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBehaviorWithDeclaration"):
                listener.enterBehaviorWithDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBehaviorWithDeclaration"):
                listener.exitBehaviorWithDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBehaviorWithDeclaration"):
                return visitor.visitBehaviorWithDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def behaviorWithDeclaration(self):
        localctx = OpenSCENARIO2Parser.BehaviorWithDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 182, self.RULE_behaviorWithDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 935
            self.match(OpenSCENARIO2Parser.T__37)
            self.state = 936
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 937
            self.match(OpenSCENARIO2Parser.NEWLINE)
            self.state = 938
            self.match(OpenSCENARIO2Parser.INDENT)
            self.state = 940
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 939
                self.behaviorWithMember()
                self.state = 942
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        (((_la - 39)) & ~0x3F) == 0
                        and (
                            (1 << (_la - 39))
                            & (
                                (1 << (OpenSCENARIO2Parser.T__38 - 39))
                                | (1 << (OpenSCENARIO2Parser.T__41 - 39))
                                | (1 << (OpenSCENARIO2Parser.T__50 - 39))
                                | (1 << (OpenSCENARIO2Parser.Identifier - 39))
                            )
                        )
                        != 0
                    )
                ):
                    break

            self.state = 944
            self.match(OpenSCENARIO2Parser.DEDENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BehaviorWithMemberContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constraintDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ConstraintDeclarationContext, 0
            )

        def modifierInvocation(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ModifierInvocationContext, 0
            )

        def untilDirective(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.UntilDirectiveContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_behaviorWithMember

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBehaviorWithMember"):
                listener.enterBehaviorWithMember(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBehaviorWithMember"):
                listener.exitBehaviorWithMember(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBehaviorWithMember"):
                return visitor.visitBehaviorWithMember(self)
            else:
                return visitor.visitChildren(self)

    def behaviorWithMember(self):
        localctx = OpenSCENARIO2Parser.BehaviorWithMemberContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 184, self.RULE_behaviorWithMember)
        try:
            self.state = 949
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__38, OpenSCENARIO2Parser.T__41]:
                self.enterOuterAlt(localctx, 1)
                self.state = 946
                self.constraintDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.Identifier]:
                self.enterOuterAlt(localctx, 2)
                self.state = 947
                self.modifierInvocation()
                pass
            elif token in [OpenSCENARIO2Parser.T__50]:
                self.enterOuterAlt(localctx, 3)
                self.state = 948
                self.untilDirective()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class LabelNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_labelName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLabelName"):
                listener.enterLabelName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLabelName"):
                listener.exitLabelName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitLabelName"):
                return visitor.visitLabelName(self)
            else:
                return visitor.visitChildren(self)

    def labelName(self):
        localctx = OpenSCENARIO2Parser.LabelNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_labelName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 951
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ActorExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def actorName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ActorNameContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_actorExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterActorExpression"):
                listener.enterActorExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitActorExpression"):
                listener.exitActorExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitActorExpression"):
                return visitor.visitActorExpression(self)
            else:
                return visitor.visitChildren(self)

    def actorExpression(self):
        localctx = OpenSCENARIO2Parser.ActorExpressionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 188, self.RULE_actorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 953
            self.actorName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class WaitDirectiveContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventSpecification(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventSpecificationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_waitDirective

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterWaitDirective"):
                listener.enterWaitDirective(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitWaitDirective"):
                listener.exitWaitDirective(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitWaitDirective"):
                return visitor.visitWaitDirective(self)
            else:
                return visitor.visitChildren(self)

    def waitDirective(self):
        localctx = OpenSCENARIO2Parser.WaitDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_waitDirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 955
            self.match(OpenSCENARIO2Parser.T__47)
            self.state = 956
            self.eventSpecification()
            self.state = 957
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EmitDirectiveContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EventNameContext, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def argumentList(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentListContext, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_emitDirective

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEmitDirective"):
                listener.enterEmitDirective(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEmitDirective"):
                listener.exitEmitDirective(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEmitDirective"):
                return visitor.visitEmitDirective(self)
            else:
                return visitor.visitChildren(self)

    def emitDirective(self):
        localctx = OpenSCENARIO2Parser.EmitDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_emitDirective)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 959
            self.match(OpenSCENARIO2Parser.T__48)
            self.state = 960
            self.eventName()
            self.state = 965
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.OPEN_PAREN:
                self.state = 961
                self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                self.state = 962
                self.argumentList()
                self.state = 963
                self.match(OpenSCENARIO2Parser.CLOSE_PAREN)

            self.state = 967
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CallDirectiveContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def methodInvocation(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.MethodInvocationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_callDirective

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCallDirective"):
                listener.enterCallDirective(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCallDirective"):
                listener.exitCallDirective(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCallDirective"):
                return visitor.visitCallDirective(self)
            else:
                return visitor.visitChildren(self)

    def callDirective(self):
        localctx = OpenSCENARIO2Parser.CallDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_callDirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 969
            self.match(OpenSCENARIO2Parser.T__49)
            self.state = 970
            self.methodInvocation()
            self.state = 971
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class UntilDirectiveContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def eventSpecification(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EventSpecificationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_untilDirective

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterUntilDirective"):
                listener.enterUntilDirective(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitUntilDirective"):
                listener.exitUntilDirective(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitUntilDirective"):
                return visitor.visitUntilDirective(self)
            else:
                return visitor.visitChildren(self)

    def untilDirective(self):
        localctx = OpenSCENARIO2Parser.UntilDirectiveContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 196, self.RULE_untilDirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 973
            self.match(OpenSCENARIO2Parser.T__50)
            self.state = 974
            self.eventSpecification()
            self.state = 975
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodInvocationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def postfixExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PostfixExpContext, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def argumentList(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentListContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_methodInvocation

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMethodInvocation"):
                listener.enterMethodInvocation(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMethodInvocation"):
                listener.exitMethodInvocation(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMethodInvocation"):
                return visitor.visitMethodInvocation(self)
            else:
                return visitor.visitChildren(self)

    def methodInvocation(self):
        localctx = OpenSCENARIO2Parser.MethodInvocationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 198, self.RULE_methodInvocation)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 977
            self.postfixExp(0)
            self.state = 978
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 980
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 60)) & ~0x3F) == 0 and (
                (1 << (_la - 60))
                & (
                    (1 << (OpenSCENARIO2Parser.T__59 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__64 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__72 - 60))
                    | (1 << (OpenSCENARIO2Parser.T__76 - 60))
                    | (1 << (OpenSCENARIO2Parser.OPEN_BRACK - 60))
                    | (1 << (OpenSCENARIO2Parser.OPEN_PAREN - 60))
                    | (1 << (OpenSCENARIO2Parser.StringLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.FloatLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.UintLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.HexUintLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.IntLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.BoolLiteral - 60))
                    | (1 << (OpenSCENARIO2Parser.Identifier - 60))
                )
            ) != 0:
                self.state = 979
                self.argumentList()

            self.state = 982
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def methodName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.MethodNameContext, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def methodImplementation(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.MethodImplementationContext, 0
            )

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def argumentListSpecification(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ArgumentListSpecificationContext, 0
            )

        def returnType(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ReturnTypeContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_methodDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMethodDeclaration"):
                listener.enterMethodDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMethodDeclaration"):
                listener.exitMethodDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMethodDeclaration"):
                return visitor.visitMethodDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def methodDeclaration(self):
        localctx = OpenSCENARIO2Parser.MethodDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 200, self.RULE_methodDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 984
            self.match(OpenSCENARIO2Parser.T__51)
            self.state = 985
            self.methodName()
            self.state = 986
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 988
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.Identifier:
                self.state = 987
                self.argumentListSpecification()

            self.state = 990
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
            self.state = 993
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__52:
                self.state = 991
                self.match(OpenSCENARIO2Parser.T__52)
                self.state = 992
                self.returnType()

            self.state = 995
            self.methodImplementation()
            self.state = 996
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ReturnTypeContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.TypeDeclaratorContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_returnType

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterReturnType"):
                listener.enterReturnType(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitReturnType"):
                listener.exitReturnType(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitReturnType"):
                return visitor.visitReturnType(self)
            else:
                return visitor.visitChildren(self)

    def returnType(self):
        localctx = OpenSCENARIO2Parser.ReturnTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_returnType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 998
            self.typeDeclarator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodImplementationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def structuredIdentifier(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.StructuredIdentifierContext, 0
            )

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def methodQualifier(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.MethodQualifierContext, 0
            )

        def argumentList(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentListContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_methodImplementation

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMethodImplementation"):
                listener.enterMethodImplementation(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMethodImplementation"):
                listener.exitMethodImplementation(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMethodImplementation"):
                return visitor.visitMethodImplementation(self)
            else:
                return visitor.visitChildren(self)

    def methodImplementation(self):
        localctx = OpenSCENARIO2Parser.MethodImplementationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 204, self.RULE_methodImplementation)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1000
            self.match(OpenSCENARIO2Parser.T__3)
            self.state = 1002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__56:
                self.state = 1001
                self.methodQualifier()

            self.state = 1015
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__53]:
                self.state = 1004
                self.match(OpenSCENARIO2Parser.T__53)
                self.state = 1005
                self.expression()
                pass
            elif token in [OpenSCENARIO2Parser.T__54]:
                self.state = 1006
                self.match(OpenSCENARIO2Parser.T__54)
                pass
            elif token in [OpenSCENARIO2Parser.T__55]:
                self.state = 1007
                self.match(OpenSCENARIO2Parser.T__55)
                self.state = 1008
                self.structuredIdentifier(0)
                self.state = 1009
                self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                self.state = 1011
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 60)) & ~0x3F) == 0 and (
                    (1 << (_la - 60))
                    & (
                        (1 << (OpenSCENARIO2Parser.T__59 - 60))
                        | (1 << (OpenSCENARIO2Parser.T__64 - 60))
                        | (1 << (OpenSCENARIO2Parser.T__72 - 60))
                        | (1 << (OpenSCENARIO2Parser.T__76 - 60))
                        | (1 << (OpenSCENARIO2Parser.OPEN_BRACK - 60))
                        | (1 << (OpenSCENARIO2Parser.OPEN_PAREN - 60))
                        | (1 << (OpenSCENARIO2Parser.StringLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.FloatLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.UintLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.HexUintLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.IntLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.BoolLiteral - 60))
                        | (1 << (OpenSCENARIO2Parser.Identifier - 60))
                    )
                ) != 0:
                    self.state = 1010
                    self.argumentList()

                self.state = 1013
                self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodQualifierContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_methodQualifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMethodQualifier"):
                listener.enterMethodQualifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMethodQualifier"):
                listener.exitMethodQualifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMethodQualifier"):
                return visitor.visitMethodQualifier(self)
            else:
                return visitor.visitChildren(self)

    def methodQualifier(self):
        localctx = OpenSCENARIO2Parser.MethodQualifierContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 206, self.RULE_methodQualifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1017
            self.match(OpenSCENARIO2Parser.T__56)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_methodName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMethodName"):
                listener.enterMethodName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMethodName"):
                listener.exitMethodName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMethodName"):
                return visitor.visitMethodName(self)
            else:
                return visitor.visitChildren(self)

    def methodName(self):
        localctx = OpenSCENARIO2Parser.MethodNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_methodName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1019
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CoverageDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def coverDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.CoverDeclarationContext, 0
            )

        def recordDeclaration(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.RecordDeclarationContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_coverageDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCoverageDeclaration"):
                listener.enterCoverageDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCoverageDeclaration"):
                listener.exitCoverageDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCoverageDeclaration"):
                return visitor.visitCoverageDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def coverageDeclaration(self):
        localctx = OpenSCENARIO2Parser.CoverageDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 210, self.RULE_coverageDeclaration)
        try:
            self.state = 1023
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__57]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1021
                self.coverDeclaration()
                pass
            elif token in [OpenSCENARIO2Parser.T__58]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1022
                self.recordDeclaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CoverDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def targetName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TargetNameContext, 0)

        def coverageArgumentList(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.CoverageArgumentListContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.CoverageArgumentListContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_coverDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCoverDeclaration"):
                listener.enterCoverDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCoverDeclaration"):
                listener.exitCoverDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCoverDeclaration"):
                return visitor.visitCoverDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def coverDeclaration(self):
        localctx = OpenSCENARIO2Parser.CoverDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 212, self.RULE_coverDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1025
            self.match(OpenSCENARIO2Parser.T__57)
            self.state = 1026
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 1028
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.Identifier:
                self.state = 1027
                self.targetName()

            self.state = 1033
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 1030
                self.coverageArgumentList()
                self.state = 1035
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1036
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
            self.state = 1037
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class RecordDeclarationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def NEWLINE(self):
            return self.getToken(OpenSCENARIO2Parser.NEWLINE, 0)

        def targetName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TargetNameContext, 0)

        def coverageArgumentList(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.CoverageArgumentListContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.CoverageArgumentListContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_recordDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterRecordDeclaration"):
                listener.enterRecordDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitRecordDeclaration"):
                listener.exitRecordDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitRecordDeclaration"):
                return visitor.visitRecordDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def recordDeclaration(self):
        localctx = OpenSCENARIO2Parser.RecordDeclarationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 214, self.RULE_recordDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1039
            self.match(OpenSCENARIO2Parser.T__58)
            self.state = 1040
            self.match(OpenSCENARIO2Parser.OPEN_PAREN)
            self.state = 1042
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.Identifier:
                self.state = 1041
                self.targetName()

            self.state = 1047
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 1044
                self.coverageArgumentList()
                self.state = 1049
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1050
            self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
            self.state = 1051
            self.match(OpenSCENARIO2Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CoverageArgumentListContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_coverageArgumentList

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class CoverageEventContext(CoverageArgumentListContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.CoverageArgumentListContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def eventName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.EventNameContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCoverageEvent"):
                listener.enterCoverageEvent(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCoverageEvent"):
                listener.exitCoverageEvent(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCoverageEvent"):
                return visitor.visitCoverageEvent(self)
            else:
                return visitor.visitChildren(self)

    class CoverageEveryContext(CoverageArgumentListContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.CoverageArgumentListContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def valueExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ValueExpContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCoverageEvery"):
                listener.enterCoverageEvery(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCoverageEvery"):
                listener.exitCoverageEvery(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCoverageEvery"):
                return visitor.visitCoverageEvery(self)
            else:
                return visitor.visitChildren(self)

    class CoverageNameArgumentContext(CoverageArgumentListContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.CoverageArgumentListContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def namedArgument(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.NamedArgumentContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCoverageNameArgument"):
                listener.enterCoverageNameArgument(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCoverageNameArgument"):
                listener.exitCoverageNameArgument(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCoverageNameArgument"):
                return visitor.visitCoverageNameArgument(self)
            else:
                return visitor.visitChildren(self)

    class CoverageExpressionContext(CoverageArgumentListContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.CoverageArgumentListContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCoverageExpression"):
                listener.enterCoverageExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCoverageExpression"):
                listener.exitCoverageExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCoverageExpression"):
                return visitor.visitCoverageExpression(self)
            else:
                return visitor.visitChildren(self)

    class CoverageRangeContext(CoverageArgumentListContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.CoverageArgumentListContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def rangeConstructor(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.RangeConstructorContext, 0
            )

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCoverageRange"):
                listener.enterCoverageRange(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCoverageRange"):
                listener.exitCoverageRange(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCoverageRange"):
                return visitor.visitCoverageRange(self)
            else:
                return visitor.visitChildren(self)

    class CoverageUnitContext(CoverageArgumentListContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.CoverageArgumentListContext
            super().__init__(parser)
            self.unitName = None  # Token
            self.copyFrom(ctx)

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCoverageUnit"):
                listener.enterCoverageUnit(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCoverageUnit"):
                listener.exitCoverageUnit(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCoverageUnit"):
                return visitor.visitCoverageUnit(self)
            else:
                return visitor.visitChildren(self)

    def coverageArgumentList(self):
        localctx = OpenSCENARIO2Parser.CoverageArgumentListContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 216, self.RULE_coverageArgumentList)
        try:
            self.state = 1075
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 100, self._ctx)
            if la_ == 1:
                localctx = OpenSCENARIO2Parser.CoverageExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1053
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1054
                self.match(OpenSCENARIO2Parser.T__53)
                self.state = 1055
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 1056
                self.expression()
                pass

            elif la_ == 2:
                localctx = OpenSCENARIO2Parser.CoverageUnitContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1057
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1058
                self.match(OpenSCENARIO2Parser.T__5)
                self.state = 1059
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 1060
                localctx.unitName = self.match(OpenSCENARIO2Parser.Identifier)
                pass

            elif la_ == 3:
                localctx = OpenSCENARIO2Parser.CoverageRangeContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1061
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1062
                self.match(OpenSCENARIO2Parser.T__59)
                self.state = 1063
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 1064
                self.rangeConstructor()
                pass

            elif la_ == 4:
                localctx = OpenSCENARIO2Parser.CoverageEveryContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1065
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1066
                self.match(OpenSCENARIO2Parser.T__34)
                self.state = 1067
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 1068
                self.valueExp()
                pass

            elif la_ == 5:
                localctx = OpenSCENARIO2Parser.CoverageEventContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1069
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1070
                self.match(OpenSCENARIO2Parser.T__27)
                self.state = 1071
                self.match(OpenSCENARIO2Parser.T__8)
                self.state = 1072
                self.eventName()
                pass

            elif la_ == 6:
                localctx = OpenSCENARIO2Parser.CoverageNameArgumentContext(
                    self, localctx
                )
                self.enterOuterAlt(localctx, 6)
                self.state = 1073
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1074
                self.namedArgument()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TargetNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_targetName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTargetName"):
                listener.enterTargetName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTargetName"):
                listener.exitTargetName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTargetName"):
                return visitor.visitTargetName(self)
            else:
                return visitor.visitChildren(self)

    def targetName(self):
        localctx = OpenSCENARIO2Parser.TargetNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_targetName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1077
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExpressionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def implication(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ImplicationContext, 0)

        def ternaryOpExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TernaryOpExpContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_expression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterExpression"):
                listener.enterExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitExpression"):
                listener.exitExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExpression"):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)

    def expression(self):
        localctx = OpenSCENARIO2Parser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_expression)
        try:
            self.state = 1081
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 101, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1079
                self.implication()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1080
                self.ternaryOpExp()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TernaryOpExpContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def implication(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ImplicationContext, 0)

        def expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ExpressionContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_ternaryOpExp

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTernaryOpExp"):
                listener.enterTernaryOpExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTernaryOpExp"):
                listener.exitTernaryOpExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTernaryOpExp"):
                return visitor.visitTernaryOpExp(self)
            else:
                return visitor.visitChildren(self)

    def ternaryOpExp(self):
        localctx = OpenSCENARIO2Parser.TernaryOpExpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_ternaryOpExp)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1083
            self.implication()
            self.state = 1084
            self.match(OpenSCENARIO2Parser.T__60)
            self.state = 1085
            self.expression()
            self.state = 1086
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 1087
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ImplicationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def disjunction(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.DisjunctionContext)
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.DisjunctionContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_implication

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterImplication"):
                listener.enterImplication(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitImplication"):
                listener.exitImplication(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitImplication"):
                return visitor.visitImplication(self)
            else:
                return visitor.visitChildren(self)

    def implication(self):
        localctx = OpenSCENARIO2Parser.ImplicationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_implication)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1089
            self.disjunction()
            self.state = 1094
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__61:
                self.state = 1090
                self.match(OpenSCENARIO2Parser.T__61)
                self.state = 1091
                self.disjunction()
                self.state = 1096
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DisjunctionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def conjunction(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.ConjunctionContext)
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ConjunctionContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_disjunction

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterDisjunction"):
                listener.enterDisjunction(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitDisjunction"):
                listener.exitDisjunction(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitDisjunction"):
                return visitor.visitDisjunction(self)
            else:
                return visitor.visitChildren(self)

    def disjunction(self):
        localctx = OpenSCENARIO2Parser.DisjunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_disjunction)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1097
            self.conjunction()
            self.state = 1102
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__62:
                self.state = 1098
                self.match(OpenSCENARIO2Parser.T__62)
                self.state = 1099
                self.conjunction()
                self.state = 1104
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ConjunctionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def inversion(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.InversionContext)
            else:
                return self.getTypedRuleContext(OpenSCENARIO2Parser.InversionContext, i)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_conjunction

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterConjunction"):
                listener.enterConjunction(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitConjunction"):
                listener.exitConjunction(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitConjunction"):
                return visitor.visitConjunction(self)
            else:
                return visitor.visitChildren(self)

    def conjunction(self):
        localctx = OpenSCENARIO2Parser.ConjunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_conjunction)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1105
            self.inversion()
            self.state = 1110
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__63:
                self.state = 1106
                self.match(OpenSCENARIO2Parser.T__63)
                self.state = 1107
                self.inversion()
                self.state = 1112
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InversionContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def inversion(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.InversionContext, 0)

        def relation(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.RelationContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_inversion

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInversion"):
                listener.enterInversion(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInversion"):
                listener.exitInversion(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInversion"):
                return visitor.visitInversion(self)
            else:
                return visitor.visitChildren(self)

    def inversion(self):
        localctx = OpenSCENARIO2Parser.InversionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_inversion)
        try:
            self.state = 1116
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__64]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1113
                self.match(OpenSCENARIO2Parser.T__64)
                self.state = 1114
                self.inversion()
                pass
            elif token in [
                OpenSCENARIO2Parser.T__59,
                OpenSCENARIO2Parser.T__72,
                OpenSCENARIO2Parser.T__76,
                OpenSCENARIO2Parser.OPEN_BRACK,
                OpenSCENARIO2Parser.OPEN_PAREN,
                OpenSCENARIO2Parser.StringLiteral,
                OpenSCENARIO2Parser.FloatLiteral,
                OpenSCENARIO2Parser.UintLiteral,
                OpenSCENARIO2Parser.HexUintLiteral,
                OpenSCENARIO2Parser.IntLiteral,
                OpenSCENARIO2Parser.BoolLiteral,
                OpenSCENARIO2Parser.Identifier,
            ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1115
                self.relation(0)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class RelationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_relation

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class RelationExpContext(RelationContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.RelationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def relation(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.RelationContext, 0)

        def relationalOp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.RelationalOpContext, 0)

        def sum_(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.SumContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterRelationExp"):
                listener.enterRelationExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitRelationExp"):
                listener.exitRelationExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitRelationExp"):
                return visitor.visitRelationExp(self)
            else:
                return visitor.visitChildren(self)

    class SumExpContext(RelationContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.RelationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def sum_(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.SumContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSumExp"):
                listener.enterSumExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSumExp"):
                listener.exitSumExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSumExp"):
                return visitor.visitSumExp(self)
            else:
                return visitor.visitChildren(self)

    def relation(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = OpenSCENARIO2Parser.RelationContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 232
        self.enterRecursionRule(localctx, 232, self.RULE_relation, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = OpenSCENARIO2Parser.SumExpContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 1119
            self.sum_(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1127
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 106, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = OpenSCENARIO2Parser.RelationExpContext(
                        self,
                        OpenSCENARIO2Parser.RelationContext(
                            self, _parentctx, _parentState
                        ),
                    )
                    self.pushNewRecursionContext(
                        localctx, _startState, self.RULE_relation
                    )
                    self.state = 1121
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException

                        raise FailedPredicateException(
                            self, "self.precpred(self._ctx, 1)"
                        )
                    self.state = 1122
                    self.relationalOp()
                    self.state = 1123
                    self.sum_(0)
                self.state = 1129
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 106, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx

    class RelationalOpContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_relationalOp

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterRelationalOp"):
                listener.enterRelationalOp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitRelationalOp"):
                listener.exitRelationalOp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitRelationalOp"):
                return visitor.visitRelationalOp(self)
            else:
                return visitor.visitChildren(self)

    def relationalOp(self):
        localctx = OpenSCENARIO2Parser.RelationalOpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_relationalOp)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1130
            _la = self._input.LA(1)
            if not (
                (
                    (((_la - 13)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 13))
                        & (
                            (1 << (OpenSCENARIO2Parser.T__12 - 13))
                            | (1 << (OpenSCENARIO2Parser.T__65 - 13))
                            | (1 << (OpenSCENARIO2Parser.T__66 - 13))
                            | (1 << (OpenSCENARIO2Parser.T__67 - 13))
                            | (1 << (OpenSCENARIO2Parser.T__68 - 13))
                            | (1 << (OpenSCENARIO2Parser.T__69 - 13))
                            | (1 << (OpenSCENARIO2Parser.T__70 - 13))
                        )
                    )
                    != 0
                )
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SumContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_sum

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class TermExpContext(SumContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.SumContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def term(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TermContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTermExp"):
                listener.enterTermExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTermExp"):
                listener.exitTermExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTermExp"):
                return visitor.visitTermExp(self)
            else:
                return visitor.visitChildren(self)

    class AdditiveExpContext(SumContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.SumContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def sum_(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.SumContext, 0)

        def additiveOp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.AdditiveOpContext, 0)

        def term(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TermContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAdditiveExp"):
                listener.enterAdditiveExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAdditiveExp"):
                listener.exitAdditiveExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAdditiveExp"):
                return visitor.visitAdditiveExp(self)
            else:
                return visitor.visitChildren(self)

    def sum_(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = OpenSCENARIO2Parser.SumContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 236
        self.enterRecursionRule(localctx, 236, self.RULE_sum, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = OpenSCENARIO2Parser.TermExpContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 1133
            self.term(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1141
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 107, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = OpenSCENARIO2Parser.AdditiveExpContext(
                        self,
                        OpenSCENARIO2Parser.SumContext(self, _parentctx, _parentState),
                    )
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_sum)
                    self.state = 1135
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException

                        raise FailedPredicateException(
                            self, "self.precpred(self._ctx, 1)"
                        )
                    self.state = 1136
                    self.additiveOp()
                    self.state = 1137
                    self.term(0)
                self.state = 1143
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 107, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx

    class AdditiveOpContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_additiveOp

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAdditiveOp"):
                listener.enterAdditiveOp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAdditiveOp"):
                listener.exitAdditiveOp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAdditiveOp"):
                return visitor.visitAdditiveOp(self)
            else:
                return visitor.visitChildren(self)

    def additiveOp(self):
        localctx = OpenSCENARIO2Parser.AdditiveOpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_additiveOp)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1144
            _la = self._input.LA(1)
            if not (
                _la == OpenSCENARIO2Parser.T__71 or _la == OpenSCENARIO2Parser.T__72
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TermContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_term

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class MultiplicativeExpContext(TermContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.TermContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def term(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.TermContext, 0)

        def multiplicativeOp(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.MultiplicativeOpContext, 0
            )

        def factor(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.FactorContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMultiplicativeExp"):
                listener.enterMultiplicativeExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMultiplicativeExp"):
                listener.exitMultiplicativeExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMultiplicativeExp"):
                return visitor.visitMultiplicativeExp(self)
            else:
                return visitor.visitChildren(self)

    class FactorExpContext(TermContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.TermContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def factor(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.FactorContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFactorExp"):
                listener.enterFactorExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFactorExp"):
                listener.exitFactorExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFactorExp"):
                return visitor.visitFactorExp(self)
            else:
                return visitor.visitChildren(self)

    def term(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = OpenSCENARIO2Parser.TermContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 240
        self.enterRecursionRule(localctx, 240, self.RULE_term, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = OpenSCENARIO2Parser.FactorExpContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 1147
            self.factor()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1155
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 108, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = OpenSCENARIO2Parser.MultiplicativeExpContext(
                        self,
                        OpenSCENARIO2Parser.TermContext(self, _parentctx, _parentState),
                    )
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_term)
                    self.state = 1149
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException

                        raise FailedPredicateException(
                            self, "self.precpred(self._ctx, 1)"
                        )
                    self.state = 1150
                    self.multiplicativeOp()
                    self.state = 1151
                    self.factor()
                self.state = 1157
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 108, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx

    class MultiplicativeOpContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_multiplicativeOp

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMultiplicativeOp"):
                listener.enterMultiplicativeOp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMultiplicativeOp"):
                listener.exitMultiplicativeOp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMultiplicativeOp"):
                return visitor.visitMultiplicativeOp(self)
            else:
                return visitor.visitChildren(self)

    def multiplicativeOp(self):
        localctx = OpenSCENARIO2Parser.MultiplicativeOpContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 242, self.RULE_multiplicativeOp)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1158
            _la = self._input.LA(1)
            if not (
                (
                    (((_la - 74)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 74))
                        & (
                            (1 << (OpenSCENARIO2Parser.T__73 - 74))
                            | (1 << (OpenSCENARIO2Parser.T__74 - 74))
                            | (1 << (OpenSCENARIO2Parser.T__75 - 74))
                        )
                    )
                    != 0
                )
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FactorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def postfixExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PostfixExpContext, 0)

        def factor(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.FactorContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_factor

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFactor"):
                listener.enterFactor(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFactor"):
                listener.exitFactor(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFactor"):
                return visitor.visitFactor(self)
            else:
                return visitor.visitChildren(self)

    def factor(self):
        localctx = OpenSCENARIO2Parser.FactorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_factor)
        try:
            self.state = 1163
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                OpenSCENARIO2Parser.T__59,
                OpenSCENARIO2Parser.T__76,
                OpenSCENARIO2Parser.OPEN_BRACK,
                OpenSCENARIO2Parser.OPEN_PAREN,
                OpenSCENARIO2Parser.StringLiteral,
                OpenSCENARIO2Parser.FloatLiteral,
                OpenSCENARIO2Parser.UintLiteral,
                OpenSCENARIO2Parser.HexUintLiteral,
                OpenSCENARIO2Parser.IntLiteral,
                OpenSCENARIO2Parser.BoolLiteral,
                OpenSCENARIO2Parser.Identifier,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1160
                self.postfixExp(0)
                pass
            elif token in [OpenSCENARIO2Parser.T__72]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1161
                self.match(OpenSCENARIO2Parser.T__72)
                self.state = 1162
                self.factor()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PostfixExpContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_postfixExp

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class PrimaryExpressionContext(PostfixExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.PostfixExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def primaryExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PrimaryExpContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPrimaryExpression"):
                listener.enterPrimaryExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPrimaryExpression"):
                listener.exitPrimaryExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPrimaryExpression"):
                return visitor.visitPrimaryExpression(self)
            else:
                return visitor.visitChildren(self)

    class CastExpressionContext(PostfixExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.PostfixExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def postfixExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PostfixExpContext, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def typeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.TypeDeclaratorContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCastExpression"):
                listener.enterCastExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCastExpression"):
                listener.exitCastExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCastExpression"):
                return visitor.visitCastExpression(self)
            else:
                return visitor.visitChildren(self)

    class FunctionApplicationExpressionContext(PostfixExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.PostfixExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def postfixExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PostfixExpContext, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def argumentList(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentListContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFunctionApplicationExpression"):
                listener.enterFunctionApplicationExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFunctionApplicationExpression"):
                listener.exitFunctionApplicationExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFunctionApplicationExpression"):
                return visitor.visitFunctionApplicationExpression(self)
            else:
                return visitor.visitChildren(self)

    class FieldAccessExpressionContext(PostfixExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.PostfixExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def postfixExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PostfixExpContext, 0)

        def fieldName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldNameContext, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFieldAccessExpression"):
                listener.enterFieldAccessExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFieldAccessExpression"):
                listener.exitFieldAccessExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFieldAccessExpression"):
                return visitor.visitFieldAccessExpression(self)
            else:
                return visitor.visitChildren(self)

    class ElementAccessExpressionContext(PostfixExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.PostfixExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def postfixExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PostfixExpContext, 0)

        def OPEN_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_BRACK, 0)

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def CLOSE_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_BRACK, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterElementAccessExpression"):
                listener.enterElementAccessExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitElementAccessExpression"):
                listener.exitElementAccessExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitElementAccessExpression"):
                return visitor.visitElementAccessExpression(self)
            else:
                return visitor.visitChildren(self)

    class TypeTestExpressionContext(PostfixExpContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a OpenSCENARIO2Parser.PostfixExpContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def postfixExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PostfixExpContext, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def typeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.TypeDeclaratorContext, 0
            )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeTestExpression"):
                listener.enterTypeTestExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeTestExpression"):
                listener.exitTypeTestExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeTestExpression"):
                return visitor.visitTypeTestExpression(self)
            else:
                return visitor.visitChildren(self)

    def postfixExp(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = OpenSCENARIO2Parser.PostfixExpContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 246
        self.enterRecursionRule(localctx, 246, self.RULE_postfixExp, _p)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            localctx = OpenSCENARIO2Parser.PrimaryExpressionContext(self, localctx)
            self._ctx = localctx
            _prevctx = localctx

            self.state = 1166
            self.primaryExp()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1198
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 112, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1196
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input, 111, self._ctx)
                    if la_ == 1:
                        localctx = OpenSCENARIO2Parser.CastExpressionContext(
                            self,
                            OpenSCENARIO2Parser.PostfixExpContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_postfixExp
                        )
                        self.state = 1168
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 5)"
                            )
                        self.state = 1169
                        self.match(OpenSCENARIO2Parser.T__1)
                        self.state = 1170
                        self.match(OpenSCENARIO2Parser.T__30)
                        self.state = 1171
                        self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                        self.state = 1172
                        self.typeDeclarator()
                        self.state = 1173
                        self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
                        pass

                    elif la_ == 2:
                        localctx = OpenSCENARIO2Parser.TypeTestExpressionContext(
                            self,
                            OpenSCENARIO2Parser.PostfixExpContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_postfixExp
                        )
                        self.state = 1175
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 4)"
                            )
                        self.state = 1176
                        self.match(OpenSCENARIO2Parser.T__1)
                        self.state = 1177
                        self.match(OpenSCENARIO2Parser.T__3)
                        self.state = 1178
                        self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                        self.state = 1179
                        self.typeDeclarator()
                        self.state = 1180
                        self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
                        pass

                    elif la_ == 3:
                        localctx = OpenSCENARIO2Parser.ElementAccessExpressionContext(
                            self,
                            OpenSCENARIO2Parser.PostfixExpContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_postfixExp
                        )
                        self.state = 1182
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 3)"
                            )
                        self.state = 1183
                        self.match(OpenSCENARIO2Parser.OPEN_BRACK)
                        self.state = 1184
                        self.expression()
                        self.state = 1185
                        self.match(OpenSCENARIO2Parser.CLOSE_BRACK)
                        pass

                    elif la_ == 4:
                        localctx = (
                            OpenSCENARIO2Parser.FunctionApplicationExpressionContext(
                                self,
                                OpenSCENARIO2Parser.PostfixExpContext(
                                    self, _parentctx, _parentState
                                ),
                            )
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_postfixExp
                        )
                        self.state = 1187
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 2)"
                            )
                        self.state = 1188
                        self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                        self.state = 1190
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la - 60)) & ~0x3F) == 0 and (
                            (1 << (_la - 60))
                            & (
                                (1 << (OpenSCENARIO2Parser.T__59 - 60))
                                | (1 << (OpenSCENARIO2Parser.T__64 - 60))
                                | (1 << (OpenSCENARIO2Parser.T__72 - 60))
                                | (1 << (OpenSCENARIO2Parser.T__76 - 60))
                                | (1 << (OpenSCENARIO2Parser.OPEN_BRACK - 60))
                                | (1 << (OpenSCENARIO2Parser.OPEN_PAREN - 60))
                                | (1 << (OpenSCENARIO2Parser.StringLiteral - 60))
                                | (1 << (OpenSCENARIO2Parser.FloatLiteral - 60))
                                | (1 << (OpenSCENARIO2Parser.UintLiteral - 60))
                                | (1 << (OpenSCENARIO2Parser.HexUintLiteral - 60))
                                | (1 << (OpenSCENARIO2Parser.IntLiteral - 60))
                                | (1 << (OpenSCENARIO2Parser.BoolLiteral - 60))
                                | (1 << (OpenSCENARIO2Parser.Identifier - 60))
                            )
                        ) != 0:
                            self.state = 1189
                            self.argumentList()

                        self.state = 1192
                        self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
                        pass

                    elif la_ == 5:
                        localctx = OpenSCENARIO2Parser.FieldAccessExpressionContext(
                            self,
                            OpenSCENARIO2Parser.PostfixExpContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_postfixExp
                        )
                        self.state = 1193
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 1)"
                            )
                        self.state = 1194
                        self.match(OpenSCENARIO2Parser.T__1)
                        self.state = 1195
                        self.fieldName()
                        pass

                self.state = 1200
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 112, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx

    class FieldAccessContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def postfixExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.PostfixExpContext, 0)

        def fieldName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldNameContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_fieldAccess

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFieldAccess"):
                listener.enterFieldAccess(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFieldAccess"):
                listener.exitFieldAccess(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFieldAccess"):
                return visitor.visitFieldAccess(self)
            else:
                return visitor.visitChildren(self)

    def fieldAccess(self):
        localctx = OpenSCENARIO2Parser.FieldAccessContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_fieldAccess)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1201
            self.postfixExp(0)
            self.state = 1202
            self.match(OpenSCENARIO2Parser.T__1)
            self.state = 1203
            self.fieldName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PrimaryExpContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def valueExp(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ValueExpContext, 0)

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_primaryExp

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPrimaryExp"):
                listener.enterPrimaryExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPrimaryExp"):
                listener.exitPrimaryExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPrimaryExp"):
                return visitor.visitPrimaryExp(self)
            else:
                return visitor.visitChildren(self)

    def primaryExp(self):
        localctx = OpenSCENARIO2Parser.PrimaryExpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_primaryExp)
        try:
            self.state = 1212
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 113, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1205
                self.valueExp()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1206
                self.match(OpenSCENARIO2Parser.T__76)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1207
                self.match(OpenSCENARIO2Parser.Identifier)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1208
                self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                self.state = 1209
                self.expression()
                self.state = 1210
                self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ValueExpContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def physicalLiteral(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.PhysicalLiteralContext, 0
            )

        def FloatLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.FloatLiteral, 0)

        def integerLiteral(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.IntegerLiteralContext, 0
            )

        def BoolLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.BoolLiteral, 0)

        def StringLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.StringLiteral, 0)

        def identifierReference(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.IdentifierReferenceContext, 0
            )

        def enumValueReference(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.EnumValueReferenceContext, 0
            )

        def listConstructor(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.ListConstructorContext, 0
            )

        def rangeConstructor(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.RangeConstructorContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_valueExp

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterValueExp"):
                listener.enterValueExp(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitValueExp"):
                listener.exitValueExp(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitValueExp"):
                return visitor.visitValueExp(self)
            else:
                return visitor.visitChildren(self)

    def valueExp(self):
        localctx = OpenSCENARIO2Parser.ValueExpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_valueExp)
        try:
            self.state = 1223
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 114, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1214
                self.physicalLiteral()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1215
                self.match(OpenSCENARIO2Parser.FloatLiteral)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1216
                self.integerLiteral()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1217
                self.match(OpenSCENARIO2Parser.BoolLiteral)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1218
                self.match(OpenSCENARIO2Parser.StringLiteral)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1219
                self.identifierReference()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1220
                self.enumValueReference()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1221
                self.listConstructor()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1222
                self.rangeConstructor()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ListConstructorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_BRACK, 0)

        def expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ExpressionContext, i
                )

        def CLOSE_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_BRACK, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_listConstructor

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterListConstructor"):
                listener.enterListConstructor(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitListConstructor"):
                listener.exitListConstructor(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitListConstructor"):
                return visitor.visitListConstructor(self)
            else:
                return visitor.visitChildren(self)

    def listConstructor(self):
        localctx = OpenSCENARIO2Parser.ListConstructorContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 254, self.RULE_listConstructor)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1225
            self.match(OpenSCENARIO2Parser.OPEN_BRACK)
            self.state = 1226
            self.expression()
            self.state = 1231
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 1227
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1228
                self.expression()
                self.state = 1233
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1234
            self.match(OpenSCENARIO2Parser.CLOSE_BRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class RangeConstructorContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_PAREN, 0)

        def expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ExpressionContext, i
                )

        def CLOSE_PAREN(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_PAREN, 0)

        def OPEN_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.OPEN_BRACK, 0)

        def CLOSE_BRACK(self):
            return self.getToken(OpenSCENARIO2Parser.CLOSE_BRACK, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_rangeConstructor

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterRangeConstructor"):
                listener.enterRangeConstructor(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitRangeConstructor"):
                listener.exitRangeConstructor(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitRangeConstructor"):
                return visitor.visitRangeConstructor(self)
            else:
                return visitor.visitChildren(self)

    def rangeConstructor(self):
        localctx = OpenSCENARIO2Parser.RangeConstructorContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 256, self.RULE_rangeConstructor)
        try:
            self.state = 1249
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.T__59]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1236
                self.match(OpenSCENARIO2Parser.T__59)
                self.state = 1237
                self.match(OpenSCENARIO2Parser.OPEN_PAREN)
                self.state = 1238
                self.expression()
                self.state = 1239
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1240
                self.expression()
                self.state = 1241
                self.match(OpenSCENARIO2Parser.CLOSE_PAREN)
                pass
            elif token in [OpenSCENARIO2Parser.OPEN_BRACK]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1243
                self.match(OpenSCENARIO2Parser.OPEN_BRACK)
                self.state = 1244
                self.expression()
                self.state = 1245
                self.match(OpenSCENARIO2Parser.T__77)
                self.state = 1246
                self.expression()
                self.state = 1247
                self.match(OpenSCENARIO2Parser.CLOSE_BRACK)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IdentifierReferenceContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fieldName(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(OpenSCENARIO2Parser.FieldNameContext)
            else:
                return self.getTypedRuleContext(OpenSCENARIO2Parser.FieldNameContext, i)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_identifierReference

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterIdentifierReference"):
                listener.enterIdentifierReference(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitIdentifierReference"):
                listener.exitIdentifierReference(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitIdentifierReference"):
                return visitor.visitIdentifierReference(self)
            else:
                return visitor.visitChildren(self)

    def identifierReference(self):
        localctx = OpenSCENARIO2Parser.IdentifierReferenceContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 258, self.RULE_identifierReference)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1256
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 117, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1251
                    self.fieldName()
                    self.state = 1252
                    self.match(OpenSCENARIO2Parser.T__1)
                self.state = 1258
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 117, self._ctx)

            self.state = 1259
            self.fieldName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArgumentListSpecificationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def argumentSpecification(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.ArgumentSpecificationContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.ArgumentSpecificationContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_argumentListSpecification

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterArgumentListSpecification"):
                listener.enterArgumentListSpecification(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitArgumentListSpecification"):
                listener.exitArgumentListSpecification(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArgumentListSpecification"):
                return visitor.visitArgumentListSpecification(self)
            else:
                return visitor.visitChildren(self)

    def argumentListSpecification(self):
        localctx = OpenSCENARIO2Parser.ArgumentListSpecificationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 260, self.RULE_argumentListSpecification)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1261
            self.argumentSpecification()
            self.state = 1266
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == OpenSCENARIO2Parser.T__7:
                self.state = 1262
                self.match(OpenSCENARIO2Parser.T__7)
                self.state = 1263
                self.argumentSpecification()
                self.state = 1268
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArgumentSpecificationContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def argumentName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentNameContext, 0)

        def typeDeclarator(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.TypeDeclaratorContext, 0
            )

        def defaultValue(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.DefaultValueContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_argumentSpecification

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterArgumentSpecification"):
                listener.enterArgumentSpecification(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitArgumentSpecification"):
                listener.exitArgumentSpecification(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArgumentSpecification"):
                return visitor.visitArgumentSpecification(self)
            else:
                return visitor.visitChildren(self)

    def argumentSpecification(self):
        localctx = OpenSCENARIO2Parser.ArgumentSpecificationContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 262, self.RULE_argumentSpecification)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1269
            self.argumentName()
            self.state = 1270
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 1271
            self.typeDeclarator()
            self.state = 1274
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == OpenSCENARIO2Parser.T__10:
                self.state = 1272
                self.match(OpenSCENARIO2Parser.T__10)
                self.state = 1273
                self.defaultValue()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArgumentNameContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_argumentName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterArgumentName"):
                listener.enterArgumentName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitArgumentName"):
                listener.exitArgumentName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArgumentName"):
                return visitor.visitArgumentName(self)
            else:
                return visitor.visitChildren(self)

    def argumentName(self):
        localctx = OpenSCENARIO2Parser.ArgumentNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_argumentName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1276
            self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArgumentListContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def positionalArgument(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.PositionalArgumentContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.PositionalArgumentContext, i
                )

        def namedArgument(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    OpenSCENARIO2Parser.NamedArgumentContext
                )
            else:
                return self.getTypedRuleContext(
                    OpenSCENARIO2Parser.NamedArgumentContext, i
                )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_argumentList

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterArgumentList"):
                listener.enterArgumentList(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitArgumentList"):
                listener.exitArgumentList(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArgumentList"):
                return visitor.visitArgumentList(self)
            else:
                return visitor.visitChildren(self)

    def argumentList(self):
        localctx = OpenSCENARIO2Parser.ArgumentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_argumentList)
        self._la = 0  # Token type
        try:
            self.state = 1301
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 123, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1278
                self.positionalArgument()
                self.state = 1283
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 120, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1279
                        self.match(OpenSCENARIO2Parser.T__7)
                        self.state = 1280
                        self.positionalArgument()
                    self.state = 1285
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 120, self._ctx)

                self.state = 1290
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == OpenSCENARIO2Parser.T__7:
                    self.state = 1286
                    self.match(OpenSCENARIO2Parser.T__7)
                    self.state = 1287
                    self.namedArgument()
                    self.state = 1292
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1293
                self.namedArgument()
                self.state = 1298
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == OpenSCENARIO2Parser.T__7:
                    self.state = 1294
                    self.match(OpenSCENARIO2Parser.T__7)
                    self.state = 1295
                    self.namedArgument()
                    self.state = 1300
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PositionalArgumentContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_positionalArgument

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPositionalArgument"):
                listener.enterPositionalArgument(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPositionalArgument"):
                listener.exitPositionalArgument(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPositionalArgument"):
                return visitor.visitPositionalArgument(self)
            else:
                return visitor.visitChildren(self)

    def positionalArgument(self):
        localctx = OpenSCENARIO2Parser.PositionalArgumentContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 268, self.RULE_positionalArgument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1303
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class NamedArgumentContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def argumentName(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ArgumentNameContext, 0)

        def expression(self):
            return self.getTypedRuleContext(OpenSCENARIO2Parser.ExpressionContext, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_namedArgument

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterNamedArgument"):
                listener.enterNamedArgument(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitNamedArgument"):
                listener.exitNamedArgument(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitNamedArgument"):
                return visitor.visitNamedArgument(self)
            else:
                return visitor.visitChildren(self)

    def namedArgument(self):
        localctx = OpenSCENARIO2Parser.NamedArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_namedArgument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1305
            self.argumentName()
            self.state = 1306
            self.match(OpenSCENARIO2Parser.T__8)
            self.state = 1307
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PhysicalLiteralContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.unitName = None  # Token

        def Identifier(self):
            return self.getToken(OpenSCENARIO2Parser.Identifier, 0)

        def FloatLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.FloatLiteral, 0)

        def integerLiteral(self):
            return self.getTypedRuleContext(
                OpenSCENARIO2Parser.IntegerLiteralContext, 0
            )

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_physicalLiteral

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPhysicalLiteral"):
                listener.enterPhysicalLiteral(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPhysicalLiteral"):
                listener.exitPhysicalLiteral(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPhysicalLiteral"):
                return visitor.visitPhysicalLiteral(self)
            else:
                return visitor.visitChildren(self)

    def physicalLiteral(self):
        localctx = OpenSCENARIO2Parser.PhysicalLiteralContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 272, self.RULE_physicalLiteral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1311
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [OpenSCENARIO2Parser.FloatLiteral]:
                self.state = 1309
                self.match(OpenSCENARIO2Parser.FloatLiteral)
                pass
            elif token in [
                OpenSCENARIO2Parser.UintLiteral,
                OpenSCENARIO2Parser.HexUintLiteral,
                OpenSCENARIO2Parser.IntLiteral,
            ]:
                self.state = 1310
                self.integerLiteral()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1313
            localctx.unitName = self.match(OpenSCENARIO2Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IntegerLiteralContext(ParserRuleContext):
        __slots__ = "parser"

        def __init__(
            self, parser, parent: ParserRuleContext = None, invokingState: int = -1
        ):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UintLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.UintLiteral, 0)

        def HexUintLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.HexUintLiteral, 0)

        def IntLiteral(self):
            return self.getToken(OpenSCENARIO2Parser.IntLiteral, 0)

        def getRuleIndex(self):
            return OpenSCENARIO2Parser.RULE_integerLiteral

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterIntegerLiteral"):
                listener.enterIntegerLiteral(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitIntegerLiteral"):
                listener.exitIntegerLiteral(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitIntegerLiteral"):
                return visitor.visitIntegerLiteral(self)
            else:
                return visitor.visitChildren(self)

    def integerLiteral(self):
        localctx = OpenSCENARIO2Parser.IntegerLiteralContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 274, self.RULE_integerLiteral)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1315
            _la = self._input.LA(1)
            if not (
                (
                    (((_la - 89)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 89))
                        & (
                            (1 << (OpenSCENARIO2Parser.UintLiteral - 89))
                            | (1 << (OpenSCENARIO2Parser.HexUintLiteral - 89))
                            | (1 << (OpenSCENARIO2Parser.IntLiteral - 89))
                        )
                    )
                    != 0
                )
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[4] = self.structuredIdentifier_sempred
        self._predicates[116] = self.relation_sempred
        self._predicates[118] = self.sum_sempred
        self._predicates[120] = self.term_sempred
        self._predicates[123] = self.postfixExp_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def structuredIdentifier_sempred(
        self, localctx: StructuredIdentifierContext, predIndex: int
    ):
        if predIndex == 0:
            return self.precpred(self._ctx, 1)

    def relation_sempred(self, localctx: RelationContext, predIndex: int):
        if predIndex == 1:
            return self.precpred(self._ctx, 1)

    def sum_sempred(self, localctx: SumContext, predIndex: int):
        if predIndex == 2:
            return self.precpred(self._ctx, 1)

    def term_sempred(self, localctx: TermContext, predIndex: int):
        if predIndex == 3:
            return self.precpred(self._ctx, 1)

    def postfixExp_sempred(self, localctx: PostfixExpContext, predIndex: int):
        if predIndex == 4:
            return self.precpred(self._ctx, 5)

        if predIndex == 5:
            return self.precpred(self._ctx, 4)

        if predIndex == 6:
            return self.precpred(self._ctx, 3)

        if predIndex == 7:
            return self.precpred(self._ctx, 2)

        if predIndex == 8:
            return self.precpred(self._ctx, 1)
